public KeyFrameAnimationInstance( IInterpolator <T> interpolator, ServerKeyFrame <T>[] keyFrames, PropertySetSnapshot snapshot, ExpressionVariant?finalValue, ServerObject target, AnimationDelayBehavior delayBehavior, TimeSpan delayTime, PlaybackDirection direction, TimeSpan duration, AnimationIterationBehavior iterationBehavior, int iterationCount, AnimationStopBehavior stopBehavior) : base(target, snapshot) { _interpolator = interpolator; _keyFrames = keyFrames; _finalValue = finalValue; _delayBehavior = delayBehavior; _delayTime = delayTime; _direction = direction; _duration = duration; _iterationBehavior = iterationBehavior; _iterationCount = iterationCount; _stopBehavior = stopBehavior; if (_iterationBehavior == AnimationIterationBehavior.Count) { _totalDuration = delayTime.Add(TimeSpan.FromTicks(iterationCount * _duration.Ticks)); } if (_keyFrames.Length == 0) { throw new InvalidOperationException("Animation has no key frames"); } if (_duration.Ticks <= 0) { throw new InvalidOperationException("Invalid animation duration"); } }
public InterpolationSettings(IInterpolator weighting, double blur) { Contract.Requires <ArgumentException>(blur > 0.5 && blur <= 2d, "Blur must be > 0.5 and <= 2"); WeightingFunction = weighting; Blur = blur; }
public GeoPoint GetPointElevation(double lat, double lon, DEMDataSet dataSet, InterpolationMode interpolationMode = InterpolationMode.Bilinear) { GeoPoint geoPoint = new GeoPoint(lat, lon); List <FileMetadata> tiles = this.GetCoveringFiles(lat, lon, dataSet); if (tiles.Count == 0) { _logger?.LogWarning($"No coverage found matching provided point {geoPoint} for dataset {dataSet.Name}"); return(null); } else { // Init interpolator IInterpolator interpolator = GetInterpolator(interpolationMode); using (RasterFileDictionary adjacentRasters = new RasterFileDictionary()) { PopulateRasterFileDictionary(adjacentRasters, tiles.First(), _IRasterService, tiles); geoPoint.Elevation = GetElevationAtPoint(adjacentRasters, tiles.First(), lat, lon, 0, interpolator); //Debug.WriteLine(adjacentRasters.Count); } // Ensures all geotifs are properly closed } return(geoPoint); }
public void HandleStateUpdate(NetworkMessage msg) { StateUpdate snapshot = MessagePackSerializer.Deserialize <StateUpdate>(msg.ReadMessage <ByteMsgBase>().payload); long offServerTicks = Utils.Timestamp - snapshot.timestamp; offServerTime = (float)offServerTicks / Utils.TICKS_PER_SEC; //TODO: latency interpolation foreach (KeyValuePair <uint, TransformProfile> pair in snapshot.gameObjectProfiles) { IInterpolator interpolator; if (!interpolatorHandlers.TryGetValue(pair.Key, out interpolator)) { GameObject obj = ClientScene.FindLocalObject(new NetworkInstanceId(pair.Key)); if (obj == null) { Debug.LogWarning("Object " + pair.Value.name + " (id: " + pair.Key + ") was not found on the client, skipping it"); continue; } IInterpolator component = obj.GetComponent <IInterpolator>(); if (component == null) { component = obj.AddComponent <BasicInterpolator>(); } interpolator = component; interpolatorHandlers[pair.Key] = component; } interpolator.AcceptState(new InterpolateStep(pair.Value, snapshot.timestamp)); } }
public IEnumerable <GeoPoint> GetPointsElevation(IEnumerable <GeoPoint> points, DEMDataSet dataSet, InterpolationMode interpolationMode = InterpolationMode.Bilinear) { if (points == null) { return(null); } IEnumerable <GeoPoint> pointsWithElevation; BoundingBox bbox = points.GetBoundingBox(); DownloadMissingFiles(dataSet, bbox); List <FileMetadata> tiles = this.GetCoveringFiles(bbox, dataSet); if (tiles.Count == 0) { return(null); } else { // Init interpolator IInterpolator interpolator = GetInterpolator(interpolationMode); using (RasterFileDictionary adjacentRasters = new RasterFileDictionary()) { // Get elevation for each point pointsWithElevation = this.GetElevationData(points, adjacentRasters, tiles, interpolator); //Debug.WriteLine(adjacentRasters.Count); } // Ensures all rasters are properly closed } return(pointsWithElevation); }
internal static Keyframe <T> NewInstance(JsonObject json, LottieComposition composition, float scale, IAnimatableValueFactory <T> valueFactory) { PointF cp1 = null; PointF cp2 = null; float startFrame = 0; var startValue = default(T); var endValue = default(T); IInterpolator interpolator = null; if (json.ContainsKey("t")) { startFrame = (float)json.GetNamedNumber("t", 0); var startValueJson = json.GetNamedArray("s", null); if (startValueJson != null) { startValue = valueFactory.ValueFromObject(startValueJson, scale); } var endValueJson = json.GetNamedArray("e", null); if (endValueJson != null) { endValue = valueFactory.ValueFromObject(endValueJson, scale); } var cp1Json = json.GetNamedObject("o", null); var cp2Json = json.GetNamedObject("i", null); if (cp1Json != null && cp2Json != null) { cp1 = JsonUtils.PointFromJsonObject(cp1Json, scale); cp2 = JsonUtils.PointFromJsonObject(cp2Json, scale); } var hold = (int)json.GetNamedNumber("h", 0) == 1; if (hold) { endValue = startValue; // TODO: create a HoldInterpolator so progress changes don't invalidate. interpolator = LinearInterpolator; } else if (cp1 != null) { cp1 = new PointF(MiscUtils.Clamp(cp1.X, -scale, scale), MiscUtils.Clamp(cp1.Y, -MaxCpValue, MaxCpValue)); cp2 = new PointF(MiscUtils.Clamp(cp2.X, -scale, scale), MiscUtils.Clamp(cp2.Y, -MaxCpValue, MaxCpValue)); interpolator = new PathInterpolator(cp1.X / scale, cp1.Y / scale, cp2.X / scale, cp2.Y / scale); } else { interpolator = LinearInterpolator; } } else { startValue = valueFactory.ValueFromObject(json, scale); endValue = startValue; } return(new Keyframe <T>(composition, startValue, endValue, interpolator, startFrame, null)); }
/// <summary> /// Adds an interpolator. /// </summary> /// <param name="interpolator">The interpolator to enable.</param> public static void AddInterpolator(IInterpolator interpolator) { if (!m_interpolators.Contains(interpolator)) { m_interpolators.Add(interpolator); } }
public void GeneratePixels(double pointResolution) { var directionVector = new Vector(-B, A).Normalize() * pointResolution; // _NormalVector.Normalize().Rotate90CCW() * pointResolution; if (directionVector.X < 0) { directionVector = directionVector.Reverse(); } var currentVector = GetFirstVector(); IInterpolator inter = InterpolateHelper.CurrentInterpolator; //наполняем пикселями Pixel temp = _Image.GetPixel(currentVector.X, currentVector.Y);//inter.GetPixel(_Image, currentVector); while (temp != null) { _Pixels.Add(temp); currentVector += directionVector; temp = _Image.GetPixel(currentVector.X, currentVector.Y);//inter.GetPixel(_Image, currentVector); } var lastAddedVector = currentVector - directionVector; var lastVector = GetLastVector(); if (lastAddedVector.X != lastVector.X && lastAddedVector.Y != lastVector.Y) { _Pixels.Add(_Image.GetPixel(lastVector.X, lastVector.Y)); } }
public void UpdateProcess_CallsIrperInterpolate(float expireT) { IInterpolatorProcesssConstArg arg = CreateMockArg(); arg.constraintValue.Returns(expireT); TestInterpolatorProcess testProcess = new TestInterpolatorProcess(arg); testProcess.Run(); IInterpolator irper = testProcess.GetInterpolator(); irper.Received(1).Interpolate(0f); IProcessManager processManager = arg.processManager; const float deltaT = .1f; for (float f = deltaT; f < expireT; f += deltaT) { float elapsedT = f; testProcess.UpdateProcess(deltaT); irper.Received(1).Interpolate(elapsedT / expireT); processManager.DidNotReceive().RemoveRunningProcess(testProcess); } testProcess.UpdateProcess(deltaT); irper.Received(1).Interpolate(1f); processManager.Received(1).RemoveRunningProcess(testProcess); }
private void BindChildAnimation(View child, int index, long duration) { bool expanded = mExpanded; int centerX = Width / 2; int centerY = Height / 2; int radius = expanded ? 0 : mRadius; int childCount = ChildCount; float perDegrees = (mToDegrees - mFromDegrees) / (childCount - 1); Rect frame = ComputeChildFrame(centerX, centerY, radius, mFromDegrees + index * perDegrees, mChildSize); int toXDelta = frame.Left - child.Left; int toYDelta = frame.Top - child.Top; IInterpolator interpolator = mExpanded ? (IInterpolator)(new AccelerateInterpolator()) : (IInterpolator)(new OvershootInterpolator(1.5f)); long startOffset = ComputeStartOffset(childCount, mExpanded, index, 0.1f, duration, interpolator); Animation animation = mExpanded ? CreateShrinkAnimation(0, toXDelta, 0, toYDelta, startOffset, duration, interpolator) : CreateExpandAnimation(0, toXDelta, 0, toYDelta, startOffset, duration, interpolator); bool isLast = GetTransformedIndex(expanded, childCount, index) == childCount - 1; animation.AnimationStart += (sender, e) => {}; animation.AnimationRepeat += (sender, e) => {}; animation.AnimationEnd += (sender, e) => { if (isLast) { PostDelayed(OnAllAnimationsEnd, 0); } }; child.Animation = animation; }
public List <GeoPoint> GetLineGeometryElevation(IGeometry lineStringGeometry, DEMDataSet dataSet, InterpolationMode interpolationMode = InterpolationMode.Bilinear) { if (lineStringGeometry == null || lineStringGeometry.IsEmpty) { return(null); } if (lineStringGeometry.OgcGeometryType != OgcGeometryType.LineString) { throw new Exception("Geometry must be a linestring"); } if (lineStringGeometry.SRID != 4326) { throw new Exception("Geometry SRID must be set to 4326 (WGS 84)"); } BoundingBox bbox = lineStringGeometry.GetBoundingBox(); List <FileMetadata> tiles = this.GetCoveringFiles(bbox, dataSet); // Init interpolator IInterpolator interpolator = GetInterpolator(interpolationMode); var ptStart = lineStringGeometry.Coordinates[0]; var ptEnd = lineStringGeometry.Coordinates.Last(); GeoPoint start = new GeoPoint(ptStart.Y, ptStart.X); GeoPoint end = new GeoPoint(ptEnd.Y, ptEnd.X); double lengthMeters = start.DistanceTo(end); int demResolution = dataSet.ResolutionMeters; int totalCapacity = 2 * (int)(lengthMeters / demResolution); List <GeoPoint> geoPoints = new List <GeoPoint>(totalCapacity); using (RasterFileDictionary adjacentRasters = new RasterFileDictionary()) { bool isFirstSegment = true; // used to return first point only for first segments, for all other segments last point will be returned foreach (GeoSegment segment in lineStringGeometry.Segments()) { List <FileMetadata> segTiles = this.GetCoveringFiles(segment.GetBoundingBox(), dataSet, tiles); // Find all intersection with segment and DEM grid IEnumerable <GeoPoint> intersections = this.FindSegmentIntersections(segment.Start.Longitude , segment.Start.Latitude , segment.End.Longitude , segment.End.Latitude , segTiles , isFirstSegment , true); // Get elevation for each point intersections = this.GetElevationData(intersections, adjacentRasters, segTiles, interpolator); // Add to output list geoPoints.AddRange(intersections); isFirstSegment = false; } //Debug.WriteLine(adjacentRasters.Count); } // Ensures all rasters are properly closed return(geoPoints); }
public Curve(TX start, Tuple <TX, double>[] keyPoints, Func <TX, double> x2DoubleFunc, Interpolation interpolation) { Start = start; KeyPoints = keyPoints; _x2DoubleFunc = x2DoubleFunc; _interpolator = interpolation.GetInterpolator(keyPoints.Select(x => Tuple.Create(_x2DoubleFunc(x.Item1), x.Item2)).ToArray()); }
public DefaultTranslator(ITranslationBackend backend, ILogger logger, IPluralResolver pluralResolver, IInterpolator interpolator) { _backend = backend; _logger = logger; _pluralResolver = pluralResolver; _interpolator = interpolator; }
/// <summary> /// Creates a sample sequence used to demonstrate scope features. /// </summary> private SampleSequence CreateDemoSampleSequence(double duration, int sampleRate, IInterpolator interpolator, int interpolatedSampleRate) { var values1 = FunctionValueGenerator.GenerateSineValuesForFrequency(1, sampleRate, duration, (x, y) => y); var values3 = FunctionValueGenerator.GenerateSineValuesForFrequency(3, sampleRate, duration, (x, y) => y / 2); var values = CollectionUtilities.Zip( objects => ((double)objects[0]) + ((double)objects[1]), values1, values3); if (interpolator != null) { values = interpolator.Interpolate(values, 0, duration, sampleRate, interpolatedSampleRate); sampleRate = interpolatedSampleRate; } // LogDeferredAccess shows us some details about how the values are accessed (see there). return(new SampleSequence(1f / sampleRate, values)); //return new SampleSequence(1/sampleFrequency, LogDeferredAccess(values)); }
public DefaultTranslator(ITranslationBackend backend, IInterpolator interpolator) { _backend = backend; _logger = new TraceLogger(); _pluralResolver = new DefaultPluralResolver(); _interpolator = interpolator; }
public static void Animate(View v, string property, long duration, IInterpolator interpolator, params float[] positions) { var anim = ObjectAnimator.OfFloat(v, property, positions); anim.SetDuration(duration); anim.SetInterpolator(interpolator); anim.Start(); }
public SlideDownAnimation(View v, int marginStart, int marginEnd, IInterpolator i) { _mStart = marginStart; _mView = v; _mChange = marginEnd - _mStart; Interpolator = i; }
public BounceAnimation(Marker marker, Handler handler) { mMarker = marker; mHandler = handler; mInterpolator = new BounceInterpolator(); mStart = SystemClock.UptimeMillis(); mDuration = 1500; }
public static void AnimateAlphaProperty(View target, long duration, long delay, float initial, float destination, IInterpolator interpolator, Action started, Action ended) { var animator = ObjectAnimator.OfFloat(target, AlphaPropertyName, initial, destination); animator.SetInterpolator(interpolator); animator.StartDelay = delay; animator.SetDuration(duration); AttachEvents(animator, started, ended); animator.Start(); }
public SwipeMenuLayout(View contentView, SwipeMenuView menuView, IInterpolator closeInterpolator, IInterpolator openInterpolator) : base(contentView.Context) { mCloseInterpolator = closeInterpolator; mOpenInterpolator = openInterpolator; ContentView = contentView; MenuView = menuView; MenuView.SwipeMenuLayout = this; Init(); }
public Keyframe(LottieComposition composition, T startValue, T endValue, IInterpolator interpolator, float?startFrame, float?endFrame) { _composition = composition; StartValue = startValue; EndValue = endValue; Interpolator = interpolator; StartFrame = startFrame; EndFrame = endFrame; }
public Builder Interpolator(IInterpolator interpolator) { if (interpolator == null) { throw new ArgumentNullException("interpolator"); } _interpolator = interpolator; return(this); }
public RotateCanvasTransformer(CanvasTransformerBuilder builder, int openedDeg, int closedDeg, int px, int py, IInterpolator interp) { this.builder = builder; this.openedDeg = openedDeg; this.closedDeg = closedDeg; this.px = px; this.py = py; this.interp = interp; }
public TranslateCanvasTransformer(CanvasTransformerBuilder builder, int openedX, int closedX, int openedY, int closedY, IInterpolator interp) { this.builder = builder; this.openedX = openedX; this.closedX = closedX; this.openedY = openedY; this.closedY = closedY; this.interp = interp; }
private void Awake() { Pool.Initialise(gameObject); interpolator = new LinearInterpolator(8.0f) { Value = 1.0f }; }
public Tweener(IInterpolator <T> interpolator, bool animatePhysics, ValueSetter <T> setter) { Debug.AssertFormat(setter != null, "[Tweener<{0}>] Attempt to create tweener with null setter", typeof(T)); Debug.AssertFormat(interpolator != null, "[Tweener<{0}>] Attempt to create tweener with null interpolator", typeof(T)); m_Setter = setter; m_Interpolator = interpolator; m_AnimatePhysics = animatePhysics ? 1f : 0f; }
public List <GeoPoint> GetLineGeometryElevation(SqlGeometry lineStringGeometry, DEMDataSet dataSet, InterpolationMode interpolationMode = InterpolationMode.Bilinear) { if (lineStringGeometry == null || lineStringGeometry.IsNull) { return(null); } if (lineStringGeometry.STGeometryType().Value != "LineString") { throw new Exception("Geometry must be a linestring"); } if (lineStringGeometry.STSrid.Value != 4326) { throw new Exception("Geometry SRID must be set to 4326 (WGS 84)"); } BoundingBox bbox = lineStringGeometry.GetBoundingBox(); List <FileMetadata> tiles = this.GetCoveringFiles(bbox, dataSet); // Init interpolator IInterpolator interpolator = GetInterpolator(interpolationMode); double lengthMeters = lineStringGeometry.STLength().Value; int demResolution = dataSet.ResolutionMeters; int totalCapacity = 2 * (int)(lengthMeters / demResolution); List <GeoPoint> geoPoints = new List <GeoPoint>(totalCapacity); using (GeoTiffDictionary adjacentGeoTiffs = new GeoTiffDictionary()) { bool isFirstSegment = true; // used to return first point only for first segments, for all other segments last point will be returned foreach (SqlGeometry segment in lineStringGeometry.Segments()) { List <FileMetadata> segTiles = this.GetCoveringFiles(segment.GetBoundingBox(), dataSet, tiles); // Find all intersection with segment and DEM grid List <GeoPoint> intersections = this.FindSegmentIntersections(segment.STStartPoint().STX.Value , segment.STStartPoint().STY.Value , segment.STEndPoint().STX.Value , segment.STEndPoint().STY.Value , segTiles , isFirstSegment , true); // Get elevation for each point this.GetElevationData(ref intersections, adjacentGeoTiffs, segTiles, interpolator); // Add to output list geoPoints.AddRange(intersections); isFirstSegment = false; } //Debug.WriteLine(adjacentGeoTiffs.Count); } // Ensures all geotifs are properly closed return(geoPoints); }
public InterpolationSettings(IInterpolator weighting, double blur) { if (blur < 0.5 || blur > 1.5) { throw new ArgumentOutOfRangeException(nameof(blur), "Value must be between 0.5 and 1.5"); } WeightingFunction = weighting ?? throw new ArgumentNullException(nameof(weighting)); this.blur = blur; }
public BounceInAnimation(Marker marker, LatLng startLatLng, LatLng target) { _mMarker = marker; _mHandler = new Handler(); _mInterpolator = new LinearInterpolator(); _mStart = SystemClock.UptimeMillis(); _mDuration = 1000; _startLatLng = startLatLng; _target = target; }
public AlphaModifier(int initialValue, int finalValue, long startMilis, long endMilis, IInterpolator interpolator) { mInitialValue = initialValue; mFinalValue = finalValue; mStartTime = startMilis; mEndTime = endMilis; mDuration = mEndTime - mStartTime; mValueIncrement = mFinalValue - mInitialValue; mInterpolator = interpolator; }
public void SetCoor(IInterpolator inter,double x, double y, double z) { this.inter = inter; this.X = x; this.Y = y; this.Z = z; this.W = inter.Interpolate(x, y,z,true)[0]; uxValue.Text = this.W.ToString(); OnChangedCoordinater(EventArgs.Empty); }
public AlmostRippleDrawable(ColorStateList tintStateList) : base(tintStateList) { Contract.Requires(tintStateList != null); _interpolator = new AccelerateDecelerateInterpolator(); SetColor(tintStateList); _updater = new Runnable(Run); }
protected override void OnCreate (Bundle savedInstanceState) { var sharedElementEnterTransition = TransitionInflater.From (this).InflateTransition (Resource.Transition.quiz_enter); Window.SharedElementEnterTransition = sharedElementEnterTransition; categoryId = Intent.GetStringExtra (Category.TAG); interpolator = AnimationUtils.LoadInterpolator (this, Android.Resource.Interpolator.FastOutSlowIn); if (savedInstanceState != null) savedStateIsPlaying = savedInstanceState.GetBoolean (StateIsPlaying); Populate (categoryId); base.OnCreate (savedInstanceState); }
public virtual AnimatorBuilder ApplyFade(View viewToFade, float fade, IInterpolator interpolator) { if (viewToFade == null) { throw new ArgumentNullException("viewToFade"); } float startAlpha = viewToFade.Alpha; listAnimatorBundles.Add(AnimatorBundle.Create(AnimatorBundle.TypeAnimation.Fade, viewToFade, interpolator, startAlpha, fade)); return this; }
public virtual AnimatorBuilder ApplyScale(View view, RectangleF finalRect, IInterpolator interpolator) { if (view == null) { throw new ArgumentNullException("view"); } var from = new RectangleF(view.Left, view.Top, view.Right, view.Bottom); var scaleX = finalRect.Width / from.Width; var scaleY = finalRect.Height / from.Height; return ApplyScale(view, scaleX, scaleY, interpolator); }
public static void TranslationYAnimate(this View view, int translation, int duration = 300, IInterpolator interpolator = null, Action endAction = null) { var animator = ViewCompat.Animate (view); animator .SetDuration (duration) .TranslationY (translation); if (endAction != null) animator.WithEndAction (new Runnable (endAction)); if (interpolator != null) animator.SetInterpolator (interpolator); animator.Start (); }
public mTrans2(ICanvasTransformer trans, IInterpolator interp, int openedX, int closedX, int openedY, int closedY, int px, int py) { mtrans = trans; minterp = interp; mopenedX = openedX; mclosedX = closedX; mopenedY = openedY; mclosedY = closedY; mpx = px; mpy = py; }
public Transition(RectF srcRect, RectF dstRect, long duration, IInterpolator interpolator) { if (!MathUtils.HaveSameAspectRatio(srcRect, dstRect)) { throw new IncompatibleRatioException(); } _mSrcRect = srcRect; _mDstRect = dstRect; _mDuration = duration; _mInterpolator = interpolator; // Precomputes a few variables to avoid doing it in onDraw(). _mWidthDiff = dstRect.Width() - srcRect.Width(); _mHeightDiff = dstRect.Height() - srcRect.Height(); _mCenterXDiff = dstRect.CenterX() - srcRect.CenterX(); _mCenterYDiff = dstRect.CenterY() - srcRect.CenterY(); }
public virtual AnimatorBuilder ApplyScale(View view, float scaleX, float scaleY, IInterpolator interpolator) { if (view == null) { throw new ArgumentNullException("view"); } AnimatorBundle animatorScaleX = AnimatorBundle.Create(AnimatorBundle.TypeAnimation.ScaleX, view, interpolator, view.ScaleX, scaleX); AnimatorBundle animatorScaleY = AnimatorBundle.Create(AnimatorBundle.TypeAnimation.ScaleY, view, interpolator, view.ScaleY, scaleY); AdjustTranslation(view); listAnimatorBundles.Add(animatorScaleX); listAnimatorBundles.Add(animatorScaleY); return this; }
public static ValueAnimator CreateValueAnimator(long duration, long delay, float initial, float destination, IInterpolator interpolator, Action started, Action ended, Action<float> update) { var animator = ValueAnimator.OfFloat(initial, destination); animator.SetDuration(duration); animator.SetInterpolator(interpolator); animator.StartDelay = delay; if (update != null) { animator.Update += delegate { update((float)animator.AnimatedValue); }; } AttachEvents(animator, started, ended); animator.Start(); return animator; }
private SmoothProgressDrawable(IInterpolator interpolator, int sectionsCount, int seperatorLength, Color[] colors, float strokeWidth, float speed, bool reversed, bool mirrorMode) { IsRunning = false; _interpolator = interpolator; _sectionsCount = sectionsCount; _seperatorLength = seperatorLength; _speed = speed; _reversed = reversed; _colors = colors; _colorIndex = 0; _mirrorMode = mirrorMode; _maxOffset = 1f / _sectionsCount; _paint = new Paint {StrokeWidth = strokeWidth, AntiAlias = false, Dither = false}; _paint.SetStyle(Paint.Style.Stroke); }
public virtual AnimatorBuilder ApplyTranslation(View view, PointF finalPoint, IInterpolator interpolator) { if (view == null) { throw new ArgumentNullException("view"); } var from = new PointF(view.Left, view.Top); var translationX = finalPoint.X - from.X; var translationY = finalPoint.Y - from.Y; return ApplyTranslation(view, translationX, translationY, interpolator); }
private static void InitValues(Context context) { var res = context.Resources; _interpolator = new AccelerateInterpolator(); _sectionsCount = res.GetInteger(Resource.Integer.spb_default_sections_count); _colors = new[]{res.GetColor(Resource.Color.spb_default_color)}; _speed = float.Parse(res.GetString(Resource.String.spb_default_speed), CultureInfo.InvariantCulture); _reversed = res.GetBoolean(Resource.Boolean.spb_default_reversed); _strokeSeparatorLength = res.GetDimensionPixelSize(Resource.Dimension.spb_default_stroke_separator_length); _strokeWidth = res.GetDimensionPixelOffset(Resource.Dimension.spb_default_stroke_width); }
public Builder Interpolator(IInterpolator interpolator) { if (interpolator == null) throw new ArgumentNullException("interpolator"); _interpolator = interpolator; return this; }
public mTrans3(ICanvasTransformer mTrans, IInterpolator interp, int openedDeg, int closedDeg, int px, int py) { // TODO: Complete member initialization this.mTrans = mTrans; this.interp = interp; this.openedDeg = openedDeg; this.closedDeg = closedDeg; this.px = px; this.py = py; }
private static long computeStartOffset(int childCount, bool expanded, int index, float delayPercent, long duration, IInterpolator interpolator) { float delay = delayPercent * duration; long viewDelay = (long)(getTransformedIndex(expanded, childCount, index) * delay); float totalDelay = delay * childCount; float normalizedDelay = viewDelay / totalDelay; normalizedDelay = interpolator.GetInterpolation(normalizedDelay); return (long)(normalizedDelay * totalDelay); }
static InterpolateHelper() { _instance = new BilinearInterpolator(); }
public ICanvasTransformer zoom(int openedX, int closedX, int openedY, int closedY, int px, int py, IInterpolator interp) { initTransformer(); //mTrans = new CanvasTransformer() { // public void transformCanvas(Canvas canvas, float percentOpen) { // mTrans.transformCanvas(canvas, percentOpen); // float f = interp.getInterpolation(percentOpen); // canvas.scale((openedX - closedX) * f + closedX, // (openedY - closedY) * f + closedY, px, py); // } //}; mTrans = new mTrans2(mTrans, interp, openedX, closedX, openedY, closedY, px, py); return mTrans; }
public RandomTransitionGenerator(long transitionDuration, IInterpolator transitionIInterpolator) { SetTransitionDuration(transitionDuration); SetTransitionIInterpolator(transitionIInterpolator); }
public mTrans4(ICanvasTransformer mTrans, IInterpolator interp, int openedX, int closedX, int openedY, int closedY) { // TODO: Complete member initialization this.mTrans = mTrans; this.interp = interp; this.openedX = openedX; this.closedX = closedX; this.openedY = openedY; this.closedY = closedY; }
private ResizeAnimation CreateResizeAnimation(float toWidth, IInterpolator interpolator, float toHeight) { var resizeAnimation = new ResizeAnimation(this._container, toWidth, toHeight) { Interpolator = interpolator, Duration = (long)(this._animationDuration * CONTAINER_ANIMATION_OFFSET) }; resizeAnimation.AnimationEnd += delegate { this.OnAnimationFinished(); }; return resizeAnimation; }
public static AnimatorBundle Create(TypeAnimation typeAnimation, View view, IInterpolator interpolator, float from, float to) { var animatorBundle = new AnimatorBundle(typeAnimation); animatorBundle.mView = view; animatorBundle.mFromValue = from; animatorBundle.mDelta = to - from; animatorBundle.mInterpolator = interpolator; return animatorBundle; }
public List<double[]> UpdatePredictedTable(IInterpolator predic, int trend, string transform) { //"Measured","Trans","Trend","Predicted","Error","StdError" List<double[]> lists= new List<double[]>(); List<double> predictedValues = new List<double>(); List<double> observedValues = new List<double>(); List<double> error = new List<double>(); List<double> stdError = new List<double>(); #region Checkvalues foreach (Feature fea1 in data.Features) { double[] value = predic.Interpolate(fea1.Coordinates[0].X, fea1.Coordinates[0].Y, fea1.Coordinates[0].Z,false); if (!value[0].Equals(double.NaN) && !value[1].Equals(double.NaN)) { if (trend != 0) { if (transform == "None") { //used= (real or trans) - trend; //(real or trans)= (used or pred) + trend; fea1.DataRow["Predicted"] = value[0] + Convert.ToDouble(fea1.DataRow["Trend"]); fea1.DataRow["Error"] = Convert.ToDouble(fea1.DataRow["Predicted"]) - Convert.ToDouble(fea1.DataRow["Measured"]); fea1.DataRow["StdError"] = value[1]; } else { fea1.DataRow["Predicted"] = check.TransformInverse(transform, (value[0] + Convert.ToDouble(fea1.DataRow["Trend"]))); fea1.DataRow["Error"] = check.TransformInverse(transform, Convert.ToDouble(fea1.DataRow["Predicted"]) - Convert.ToDouble(fea1.DataRow["Measured"])); fea1.DataRow["StdError"] = check.TransformInverse(transform, value[1]); } } else { if (transform == "None") { //used= (real or trans) - trend; //(real or trans)= (used or pred) + trend; fea1.DataRow["Predicted"] = value[0]; ; fea1.DataRow["Error"] = Convert.ToDouble(fea1.DataRow["Predicted"]) - Convert.ToDouble(fea1.DataRow["Used"]); fea1.DataRow["StdError"] = value[1]; } else { fea1.DataRow["Predicted"] = check.TransformInverse(transform, (value[0])); fea1.DataRow["Error"] = check.TransformInverse(transform, Convert.ToDouble(fea1.DataRow["Predicted"]) - Convert.ToDouble(fea1.DataRow["Used"])); fea1.DataRow["StdError"] = check.TransformInverse(transform, value[1]); } } predictedValues.Add(Convert.ToDouble(fea1.DataRow["Predicted"])); observedValues.Add(Convert.ToDouble(fea1.DataRow["Measured"])); error.Add(Convert.ToDouble(fea1.DataRow["Error"])); stdError.Add(Convert.ToDouble(fea1.DataRow["StdError"])); } } #endregion lists.Add(observedValues.ToArray()); lists.Add(predictedValues.ToArray()); lists.Add(error.ToArray()); lists.Add(stdError.ToArray()); return lists; }
private static Animation createExpandAnimation(float fromXDelta, float toXDelta, float fromYDelta, float toYDelta, long startOffset, long duration, IInterpolator interpolator) { Animation animation = new RotateAndTranslateAnimation(0, toXDelta, 0, toYDelta, 0, 720); animation.StartOffset = startOffset; animation.Duration = duration; animation.Interpolator = interpolator; animation.FillAfter = true; return animation; }
private static Animation createShrinkAnimation(float fromXDelta, float toXDelta, float fromYDelta, float toYDelta, long startOffset, long duration, IInterpolator interpolator) { AnimationSet animationSet = new AnimationSet(false); animationSet.FillAfter = true; long preDuration = duration / 2; Animation rotateAnimation = new RotateAnimation(0, 360, Dimension.RelativeToSelf, 0.5f, Dimension.RelativeToSelf, 0.5f); rotateAnimation.StartOffset = startOffset; rotateAnimation.Duration = preDuration; rotateAnimation.Interpolator = new LinearInterpolator(); rotateAnimation.FillAfter = true; animationSet.AddAnimation(rotateAnimation); Animation translateAnimation = new RotateAndTranslateAnimation(0, toXDelta, 0, toYDelta, 360, 720); translateAnimation.StartOffset = startOffset + preDuration; translateAnimation.Duration = duration - preDuration; translateAnimation.Interpolator = interpolator; translateAnimation.FillAfter = true; animationSet.AddAnimation(translateAnimation); return animationSet; }
public ICanvasTransformer rotate(int openedDeg, int closedDeg, int px, int py, IInterpolator interp) { initTransformer(); //mTrans = new CanvasTransformer() { // public void transformCanvas(Canvas canvas, float percentOpen) { // mTrans.transformCanvas(canvas, percentOpen); // float f = interp.getInterpolation(percentOpen); // canvas.rotate((openedDeg - closedDeg) * f + closedDeg, // px, py); // } //}; mTrans = new mTrans3(mTrans, interp, openedDeg, closedDeg, px, py); return mTrans; }
/** * Sets the {@link IInterpolator} for each transition generated. * @param IInterpolator the transition IInterpolator. */ public void SetTransitionIInterpolator(IInterpolator interpolator) { _mTransitionIInterpolator = interpolator; }
public ObjectAnimator StartAnimation(IInterpolator interpolator, long duration, Path path) { // This ObjectAnimator uses the path to change the x and y scale of the view object ObjectAnimator animator = ObjectAnimator.OfFloat(view,"ScaleX","ScaleY",path); // Set the interpolator and duration for this animation animator.SetDuration (duration); animator.SetInterpolator (interpolator); animator.Start (); return animator; }
void InitCustomViewAbove() { if (Android.OS.Build.VERSION.SdkInt >= BuildVersionCodes.Honeycomb) _interpolator = new CVAInterpolator(); TouchMode = TouchMode.Margin; SetWillNotDraw(false); DescendantFocusability = DescendantFocusability.AfterDescendants; Focusable = true; _scroller = new Scroller(Context, _interpolator); var configuration = ViewConfiguration.Get(Context); _touchSlop = ViewConfigurationCompat.GetScaledPagingTouchSlop(configuration); _minimumVelocity = configuration.ScaledMinimumFlingVelocity; MaximumVelocity = configuration.ScaledMaximumFlingVelocity; var density = Context.Resources.DisplayMetrics.Density; _flingDistance = (int) (MinDistanceForFling*density); PageSelected += (sender, args) => { if (_viewBehind == null) return; switch (args.Position) { case 0: case 2: _viewBehind.ChildrenEnabled = true; break; case 1: _viewBehind.ChildrenEnabled = false; break; } }; }
public List<double[]> UpdatePredictedTableDeterministics(IInterpolator predic, int trend, string transform) { //"Measured","Trans","Trend","Predicted","Error","StdError" List<double[]> lists = new List<double[]>(); List<double> predictedValues = new List<double>(); List<double> observedValues = new List<double>(); List<double> error = new List<double>(); #region Checkvalues foreach (Feature fea1 in data.Features) { double[] value = predic.Interpolate(fea1.Coordinates[0].X, fea1.Coordinates[0].Y,fea1.Coordinates[0].Z, false); if (value[0].Equals(double.NaN)) break; fea1.DataRow["Predicted"] = value[0] ; fea1.DataRow["Error"] = Convert.ToDouble(fea1.DataRow["Predicted"]) - Convert.ToDouble(fea1.DataRow["Measured"]); predictedValues.Add(Convert.ToDouble(fea1.DataRow["Predicted"])); observedValues.Add(Convert.ToDouble(fea1.DataRow["Measured"])); error.Add(Convert.ToDouble(fea1.DataRow["Error"])); } #endregion lists.Add(observedValues.ToArray()); lists.Add(predictedValues.ToArray()); lists.Add(error.ToArray()); return lists; }