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;
}
