protected void UpdateInterpolation() { int count = _keyFrames.Count; var xs = new double[count]; var ys = new double[count]; for (int i = 0; i < count; ++i) { xs[i] = (double)_keyFrames[i].time; ys[i] = (double)_keyFrames[i].value; } if (count <= 1) { _interpolation = StepInterpolation.Interpolate(xs, ys); } else if (count <= 2) { _interpolation = LinearSpline.Interpolate(xs, ys); } else if (count <= 3) { _interpolation = MathNet.Numerics.Interpolate.Polynomial(xs, ys); } else if (count <= 4) { _interpolation = CubicSpline.InterpolateNatural(xs, ys); } else { _interpolation = CubicSpline.InterpolateAkima(xs, ys); } }
public UniformDistributionFormulaSpecificationFactory( IInterpolation interpolation, OSPSuite.Core.Domain.Formulas.IDistributionFormulaFactory distributionFormulaFactory) { _interpolation = interpolation; _distributionFormulaFactory = distributionFormulaFactory; }
public DistributedParameterToTableParameterConverter( IFormulaFactory formulaFactory, IEntityPathResolver entityPathResolver, IParameterFactory parameterFactory, ICloneManager cloneManager, IParameterQuery parameterQuery, IDimensionRepository dimensionRepository, IOntogenyRepository ontogenyRepository, IFullPathDisplayResolver fullPathDisplayResolver, IInterpolation interpolation, IParameterStartValuesCreator parameterStartValuesCreator, IObjectPathFactory objectPathFactory, IGenderRepository genderRepository) { _formulaFactory = formulaFactory; _entityPathResolver = entityPathResolver; _parameterFactory = parameterFactory; _cloneManager = cloneManager; _parameterQuery = parameterQuery; _dimensionRepository = dimensionRepository; _ontogenyRepository = ontogenyRepository; _fullPathDisplayResolver = fullPathDisplayResolver; _interpolation = interpolation; _parameterStartValuesCreator = parameterStartValuesCreator; _objectPathFactory = objectPathFactory; _genderRepository = genderRepository; _timeDimension = dimensionRepository.Time; _yearUnit = _timeDimension.Unit(dimensionRepository.AgeInYears.BaseUnit.Name); }
private static void SaveMoleculePixelsToFile(IInterpolation molInterpolation, Molecule molecule, int channel, string outputDir) { int[] fitPositions = new int[molecule.Pixels[channel - 1].Length]; for (int pixelPosition = 0; pixelPosition < molecule.Pixels[channel - 1].Length; pixelPosition++) { fitPositions[pixelPosition] = (int)(Math.Round(molInterpolation.Interpolate(pixelPosition))); } string outputFileName = "molecule_" + molecule.MoleculeId.ToString() + "_channel" + channel.ToString() + ".txt"; string subdirPath = Path.Combine(outputDir, "channel" + channel.ToString()); if (!Directory.Exists(subdirPath)) { Directory.CreateDirectory(subdirPath); } string outputFilePath = Path.Combine(subdirPath, outputFileName); using (StreamWriter sw = new StreamWriter(outputFilePath)) { sw.WriteLine("track type=bedGraph name=\"molecule_" + molecule.MoleculeId.ToString() + "_channel" + channel.ToString() + "\""); if (molecule.Orientation == "+") { WritePlusOrientationMol(molecule, fitPositions, channel, sw); } else { WriteMinusOrientationMol(molecule, fitPositions, channel, sw); } } }
protected override void Context() { _interpolation = A.Fake <IInterpolation>(); _distrFormulaFactory = A.Fake <IDistributionFormulaFactory>(); sut = new NormalDistributionFormulaSpecificationFactory(_interpolation, _distrFormulaFactory); }
//http://numerics.mathdotnet.com/api/MathNet.Numerics.Interpolation/CubicSpline.htm /// <summary> /// Sets the interpolation formula. /// </summary> /// <param name="interpolation">The interpolation.</param> public void SetInterpolation(IInterpolation interpolation) { this.GetCost = null; this.GetCost = new CalculateCost(interpolation.Interpolate); interpolation = null; this.CostCalculationType = CostCalculationMethod.Interpolation; }
//XXXIS add more things if we need them? public EssesFlowCacheContext(Flow flow, UInt64 cacheSizeAllocated, CacheWritePolicy writePolicy, CacheWriteBuffer cacheWrites, string cacheCurvePointsFile, string tenantID) { Flow = flow; this.cacheSizeAllocated = cacheSizeAllocated; this.writePolicy = writePolicy; this.cacheWrites = cacheWrites; this.hitRate = 0.0F; this.tenantID = tenantID; this.demandPointsSerializationFile = cacheCurvePointsFile; if (File.Exists(this.demandPointsSerializationFile)) { readInCacheCurve(); this.useSerializedCurve = true; } else { this.cacheDemandCurvePoints = null; this.cacheDemandFunc = null; this.useSerializedCurve = false; } #if COLLECT_CACHE_CURVE Console.CancelKeyPress += new ConsoleCancelEventHandler(Controller_CancelKeyPress); #endif }
public void FitsAtArbitraryPoints(double t, double x, double maxAbsoluteError) { IInterpolation it = CubicSpline.InterpolateAkima(_t, _y); // TODO: Verify the expected values (that they are really the expected ones) Assert.AreEqual(x, it.Interpolate(t), maxAbsoluteError, "Interpolation at {0}", t); }
private void BtnSelect_Click(object sender, RoutedEventArgs e) { City city = cbCities.SelectedItem as City; if (city != null) { string[] timeString = dpDate.Text.Split('/'); DateTime dateVal = new DateTime(int.Parse(timeString[2]), int.Parse(timeString[1]), int.Parse(timeString[0])); Report rp = city.GetReport(dateVal); Report rpBefore = city.GetReport(dateVal.AddDays(-1)); Report rpAfter = city.GetReport(dateVal.AddDays(1)); //Create polynomial interpolation for temperatures IInterpolation interpolation = Utils.TemperaturesInterpolation(rpBefore.TMax, rp.TMin, rp.TMax, rpAfter.TMin); //Create polynomial interpolation for pressures IInterpolation interpolationPressure = Utils.PressuresInterpolation(rpBefore.LastPressure(), rp.Pressures, rpAfter.FirstPressure()); dgForecast.Items.Clear(); for (int i = 0; i < 24; i++) { double tempe = interpolation.Interpolate(i); double pressure = interpolationPressure.Interpolate(i); double weather = rp.Weather[i]; dgForecast.Items.Add(new HourlyReport { Hour = i + "h", Temperature = tempe.ToString("0.0") + "°", Color = GetTemperatureColor(tempe), Pressure = pressure.ToString("0.0 hp"), Icon = ViewUtils.IconPath(ViewUtils.WeatherToIcon(weather)) }); } } }
public static void Apply( IInterpolation interpolator, Span <Color> toPixels, Color color, float time, float intensity, int effectLength) { var start = Math.Abs(time) % toPixels.Length; int startPixel = (int)start; float tStep = 1 / (float)effectLength; float timeOffset = tStep * (1 - Math.Abs(start - (int)start)); for (int i = 0; i < effectLength; i++) { float t = 1 - (tStep * i + timeOffset); var interpolation = interpolator.Interpolate(t); float colorIntensity = (float)MathUtil.Clamp(0, 1, interpolation * intensity); int index = (startPixel + i) % toPixels.Length; if (index < toPixels.Length) { toPixels[index] = toPixels[index].Add( Color.FromArgb( (int)(color.R * colorIntensity), (int)(color.G * colorIntensity), (int)(color.B * colorIntensity))); } } }
private static Task <Location> InterpolateLocationAsync(DateTime relativeTo, Location initialLocation, IEnumerable <Segment> segments) { IList <double> longitudes = new List <double>(); IList <double> latitudes = new List <double>(); IList <double> timeSpans = new List <double>(); TimeSpan currentTimeSpan = TimeSpan.Zero; TimeSpan myTimeSpan = TimeSpan.Zero; longitudes.Add(initialLocation.Longitude); latitudes.Add(initialLocation.Latitude); timeSpans.Add(currentTimeSpan.TotalSeconds); foreach (Segment segment in segments) { longitudes.Add(segment.Longitude); latitudes.Add(segment.Latitude); currentTimeSpan += segment.TimeSpan; timeSpans.Add(currentTimeSpan.TotalSeconds); } myTimeSpan = relativeTo - initialLocation.DateTime; IInterpolation longitudesInterpolation = Interpolate.Linear(timeSpans, longitudes); IInterpolation latitudesInterpolation = Interpolate.Linear(timeSpans, latitudes); return(Task.FromResult( new Location { Longitude = longitudesInterpolation.Interpolate(myTimeSpan.TotalSeconds), Latitude = latitudesInterpolation.Interpolate(myTimeSpan.TotalSeconds), DateTime = relativeTo })); }
public IMask GetQuarterFadedCircle(int radius, float fade, IInterpolation interpolation) { if (radius < 0 || fade > 1 || fade < 0) { throw new ArgumentException(); } int fadeBegin = (int)(radius * (1 - fade)); var brushmask = new Mask(new Vector2(radius, radius)); for (int y = 0; y < radius; y++) { var li = (int)JryMath.Sqrt(radius * radius - (radius - y) * (radius - y)); for (int x = 0; x < li; x++) { var yCor = radius - y; float val = 1; var dis = JryMath.Sqrt(x * x + yCor * yCor); if (dis > fadeBegin) { val = interpolation.Interpolate(1, 0, (dis - fadeBegin) / (radius - fadeBegin)); } brushmask[x, yCor - 1] = val; } } return(brushmask); }
/// <summary> /// Main ctor. /// </summary> /// <param name="discreteCurve"></param> /// <param name="interpolation"></param> /// <param name="allowExtrapolation"></param> public InterpolatedCurve(IDiscreteSpace discreteCurve, IInterpolation interpolation, bool allowExtrapolation) : base(discreteCurve, interpolation, allowExtrapolation) { var xArray = GetDiscreteSpace().GetCoordinateArray(1); var yArray = GetDiscreteSpace().GetFunctionValueArray(); Interpolation.Initialize(xArray, yArray); }
/// <summary> /// Constructor. /// </summary> /// <param name="edgeWavelength">Absorbtion edge wavelength /// calibration array.</param> /// <param name="tempetature">Temperature calibration array.</param> public Calibration_Points(double[] edgeWavelength, double[] tempetature) { EdgeWavelength = edgeWavelength; Temperature = tempetature; // interpolation = MathNet.Numerics.Interpolate.Linear(EdgeWavelength, Temperature); interpolation = MathNet.Numerics.Interpolate.CubicSpline(EdgeWavelength, Temperature); }
public static IInterpolation GetLinearInterpolationMethod(Peak peak) { peak.GetXAndYValuesAsLists(out var xValues, out var yValues); IInterpolation interpolation = LinearSpline.Interpolate(xValues, yValues); return(interpolation); }
/// <summary> /// Gets the skew. /// </summary> /// <param name="wingParameterList">The wing parameter list.</param> /// <param name="xInterp">The x interp.</param> /// <param name="time">The time.</param> /// <param name="strike">The strike.</param> /// <returns></returns> public static double GetWingSkew(List <OrcWingParameters> wingParameterList, IInterpolation xInterp, double time, double strike) { const double eps = 0.0001; double f1 = GetWingValue(wingParameterList, xInterp, time, strike * (1 + eps)); double f0 = GetWingValue(wingParameterList, xInterp, time, strike * (1 - eps)); return((f1 - f0) / (2 * eps * strike)); }
private IInterpolation interpolation_U(UV point, Index index) { IndexRange horizontalExpansion = this.horizontalRange(index); //getting all vertical ranges of the horizontal IndexRange[] verticals = new IndexRange[horizontalExpansion.Length]; Index next = horizontalExpansion.Min.Copy(); for (int i = 0; i < horizontalExpansion.Length; i++) { verticals[i] = this.verticalRange(next); next.I++; } //getting interpolators for u values IInterpolation[] verticalsU = new IInterpolation[horizontalExpansion.Length]; for (int i = 0; i < verticals.Length; i++) { verticalsU[i] = this.toInterpolation(verticals[i]); } //generating u interpolation double[] x = new double[horizontalExpansion.Length]; double[] y = new double[horizontalExpansion.Length]; next = horizontalExpansion.Min.Copy(); for (int i = 0; i < horizontalExpansion.Length; i++) { x[i] = this._cellularFloor.FindCell(next).U; y[i] = verticalsU[i].Interpolate(point.V); next.I++; } IInterpolation interpolatorU = null; switch (Activity.InterpolationMethod) { case SpatialAnalysis.FieldUtility.InterpolationMethod.CubicSpline: if (x.Length > 1) { interpolatorU = CubicSpline.InterpolateBoundariesSorted(x, y, SplineBoundaryCondition.Natural, 0, SplineBoundaryCondition.Natural, 0); } else { interpolatorU = LinearSpline.InterpolateSorted(x, y); } break; //case FieldUtility.InterpolationMethod.Barycentric: // interpolatorU = Barycentric.InterpolatePolynomialEquidistantSorted(x, y); // break; case SpatialAnalysis.FieldUtility.InterpolationMethod.Linear: interpolatorU = LinearSpline.InterpolateSorted(x, y); break; default: break; } return(interpolatorU); }
public void FitsAtSamplePoints() { IInterpolation it = Barycentric.InterpolatePolynomialEquidistant(Tmin, Tmax, _y); for (int i = 0; i < _y.Length; i++) { Assert.AreEqual(_y[i], it.Interpolate(i), "A Exact Point " + i); } }
public CurveEffect( NeoPixelSetup neoPixelSetup, IColorProvider colorProvider, IInterpolation interpolator) { this.neoPixelSetup = neoPixelSetup; this.ColorProvider = colorProvider; this.Interpolator = interpolator; }
/// <summary> /// Main ctor. /// </summary> /// <param name="discreteSurface">The discrete surface ie 2 dimensional.</param> /// <param name="forwards">The forwards to be used for calibration.</param> /// <param name="xInterpolation">The basic interpolation to be applied to the x axis.</param> /// <param name="yInterpolation">The interpolation type for the y axis</param> /// <param name="allowExtrapolation">Not implemented in EO.</param> protected ExtendedInterpolatedSurface(DiscreteSurface discreteSurface, ParametricAdjustmentPoint[] forwards, IInterpolation xInterpolation, IInterpolation yInterpolation, bool allowExtrapolation) : base(discreteSurface, xInterpolation, yInterpolation, allowExtrapolation) { var values = discreteSurface.GetMatrixOfValues(); var x = discreteSurface.XArray; var width = values.ColumnCount; if (forwards != null) { SpotValue = (double)forwards[0].parameterValue; var length = forwards.Length; var fwds = new double[length - 1]; for (var index = 1; index < length; index++) { fwds[index - 1] = (double)forwards[index].parameterValue; } var fwdcurve = new LinearInterpolation(); fwdcurve.Initialize(x, fwds); ForwardCurve = fwdcurve; } if (yInterpolation.GetType() == typeof(SABRModelInterpolation)) { var y = discreteSurface.YArray; var length = values.RowCount; for (int i = 0; i < length; i++) { //interpolate each maturity first (in strike) with SABR var yinterp = (SABRModelInterpolation)yInterpolation.Clone(); yinterp.ExpiryTime = x[i]; if (Forward != null && Spot != null) { yinterp.AssetPrice = Convert.ToDecimal(Forward); } else { var fwd = ForwardCurve.ValueAt(yinterp.ExpiryTime, true); yinterp.AssetPrice = Convert.ToDecimal(fwd); } yinterp.Initialize(y, values.Row(i).Data); var curve = new DiscreteCurve(y, values.Row(i).Data); var interpolatedCol = new InterpolatedCurve(curve, yinterp, true); _interpolatedColumns.Add(interpolatedCol); } } else //o.w interpolate at each strike point (in time) { for (int i = 0; i < width; i++) { var interp = xInterpolation.Clone(); interp.Initialize(x, values.Column(i).Data); var curve = new DiscreteCurve(x, values.Column(i).Data); var interpolatedCol = new InterpolatedCurve(curve, interp, true); _interpolatedColumns.Add(interpolatedCol); } } }
public void FitsAtSamplePoints() { IInterpolation it = CubicSpline.InterpolatePchip(_t, _y); for (int i = 0; i < _y.Length; i++) { Assert.AreEqual(_y[i], it.Interpolate(_t[i]), "A Exact Point " + i); } }
public void FitsAtSamplePoints() { IInterpolation interpolation = BulirschStoerRationalInterpolation.Interpolate(_t, _x); for (int i = 0; i < _x.Length; i++) { Assert.AreEqual(_x[i], interpolation.Interpolate(_t[i]), "A Exact Point " + i); } }
public void FixedFirstDerivativeFitsAtSamplePoints() { IInterpolation it = CubicSpline.InterpolateBoundaries(_t, _y, SplineBoundaryCondition.FirstDerivative, 1.0, SplineBoundaryCondition.FirstDerivative, -1.0); for (int i = 0; i < _y.Length; i++) { Assert.AreEqual(_y[i], it.Interpolate(_t[i]), "A Exact Point " + i); } }
public void PolyomnialFitsAtSamplePoints() { IInterpolation it = Barycentric.InterpolateRationalFloaterHormann(_t, _y); for (int i = 0; i < _y.Length; i++) { Assert.AreEqual(_y[i], it.Interpolate(_t[i]), "A Exact Point " + i); } }
public void TestAllInterpolations() { Random r = new Random(Environment.TickCount); foreach (string interp in _linearInterpolations) { TearDown(); IInterpolation interpolation = InterpolationFactory.Create(interp); interpolation.Initialize(_times, _rates); Debug.WriteLine($"interpolationType : {interp}"); for (int i = 1; i < 100; ++i) { double time = (i + r.Next(-10000, 10000) / 10000) / 10.0; double interpRate = interpolation.ValueAt(time, true); Debug.WriteLine($"interpolatedRate : {interpRate} Time: {time}"); } int index = 0; foreach (double time in _times) { if (time != 0.0) { double interpRate = interpolation.ValueAt(time, true); double interpValue = _rates[index]; Assert.AreEqual(interpRate, interpValue, 10 - 8); } index++; } } foreach (string interp in _logLinearInterpolations) { TearDown(); double[] exp = SetUp(); double[] temp = new double[exp.Length]; exp.CopyTo(temp, 0); IInterpolation interpolation = InterpolationFactory.Create(interp); interpolation.Initialize(_times, temp); Debug.WriteLine($"interpolationType : {interp}"); for (int i = 1; i < 100; ++i) { double time = (i + r.Next(-10000, 10000) / 10000) / 10.0; double interpRate = interpolation.ValueAt(time, true); Debug.WriteLine($"interpolatedRate : {interpRate} Time: {time}"); } int index = 0; foreach (double time in _times) { if (time != 0.0) { double interpRate = interpolation.ValueAt(time, true); double interpValue = exp[index]; Assert.AreEqual(interpRate, interpValue, 10 - 8); } index++; } } }
public void NaturalSupportsLinearCase(int samples) { LinearInterpolationCase.Build(out var x, out var y, out var xtest, out var ytest, samples); IInterpolation it = CubicSpline.InterpolateNatural(x, y); for (int i = 0; i < xtest.Length; i++) { Assert.AreEqual(ytest[i], it.Interpolate(xtest[i]), 1e-15, "Linear with {0} samples, sample {1}", samples, i); } }
//http://numerics.mathdotnet.com/api/MathNet.Numerics.Interpolation/CubicSpline.htm /// <summary> /// Sets the interpolation formula. /// </summary> /// <param name="x">The x.</param> /// <param name="y">The y.</param> public void SetInterpolation(IEnumerable <double> x, IEnumerable <double> y) { this.GetCost = null; IInterpolation interpolation = CubicSpline.InterpolateBoundariesSorted(x.ToArray(), y.ToArray(), SplineBoundaryCondition.Natural, 0, SplineBoundaryCondition.Natural, 0); this.GetCost = new CalculateCost(interpolation.Interpolate); interpolation = null; this.CostCalculationType = CostCalculationMethod.Interpolation; }
/// <summary> /// Initializes a new instance of the <see cref="WalkingTrail"/> class. For Internal Use ONLY! /// </summary> /// <param name="observedPoints">The observed locations.</param> /// <param name="velocityMagnitude">The velocity magnitude.</param> internal WalkingTrail(UV[] observedPoints, double velocityMagnitude) { this._length = new double[observedPoints.Length]; this._trailLength = 0; this._length[0] = 0; for (int i = 0; i < observedPoints.Length - 1; i++) { double d = observedPoints[i].DistanceTo(observedPoints[i + 1]); this._length[i + 1] = this._length[i] + d; } this._trailLength = this._length[this._length.Length - 1]; double[] observation_time = new double[this._length.Length]; observation_time[0] = 0; for (int i = 0; i < observedPoints.Length - 1; i++) { double deltaT = observedPoints[i].DistanceTo(observedPoints[i + 1]) / velocityMagnitude; observation_time[i + 1] = observation_time[i] + deltaT; } this._trailInput = TrailInput.Location; this._observationTime = observation_time; this._startTime = _observationTime[0]; this._endTime = _observationTime[_observationTime.Length - 1]; this._duration = _observationTime[_observationTime.Length - 1] - _observationTime[0]; this._timeToLength = Interpolate.CubicSplineRobust(this._observationTime, this._length); this._lengthToTime = Interpolate.CubicSplineRobust(this._length, this._observationTime); //create interpolations double[] location_U_values = new double[this._observationTime.Length]; double[] location_V_values = new double[this._observationTime.Length]; for (int i = 0; i < this._observationTime.Length; i++) { location_U_values[i] = observedPoints[i].U; location_V_values[i] = observedPoints[i].V; } this._interpolate_location_U = Interpolate.CubicSplineRobust(this._observationTime, location_U_values); this._ULinearInterpolation = Interpolate.Linear(this._observationTime, location_U_values); this._interpolate_location_V = Interpolate.CubicSplineRobust(this._observationTime, location_V_values); this._VLinearInterpolation = Interpolate.Linear(this._observationTime, location_V_values); this._observedStates = new StateBase[this._observationTime.Length]; //this._controlPoints = new UV[this._time.Length]; for (int i = 0; i < this._observedStates.Length; i++) { UV location = observedPoints[i]; UV velocity = this.getVelocity(this._observationTime[i]); UV direction = this.getDirection(this._observationTime[i]); //this._controlPoints[i] = location; this._observedStates[i] = new StateBase(location, direction, velocity); } this.loadNormalizedStates(); loadApproximatedPolyline(); }
public void SupportsLinearCase(int samples) { double[] x, y, xtest, ytest; LinearInterpolationCase.Build(out x, out y, out xtest, out ytest, samples); IInterpolation it = CubicSpline.InterpolatePchip(x, y); for (int i = 0; i < xtest.Length; i++) { Assert.AreEqual(ytest[i], it.Interpolate(xtest[i]), 1e-15, "Linear with {0} samples, sample {1}", samples, i); } }
public void SupportsLinearCase(int samples) { double[] x, y, xtest, ytest; LinearInterpolationCase.Build(out x, out y, out xtest, out ytest, samples); IInterpolation it = Barycentric.InterpolateRationalFloaterHormann(x, y); for (int i = 0; i < xtest.Length; i++) { Assert.AreEqual(ytest[i], it.Interpolate(xtest[i]), 1e-14, "Linear with {0} samples, sample {1}", samples, i); } }
public MoveXModifier(double duration, double fromX, double toX, IEntityModifierListener listener, IInterpolation function) : base(duration, fromX, toX, listener, function) { }
private void readInCacheCurve() { string[] lines = System.IO.File.ReadAllLines(this.demandPointsSerializationFile); Double[] xVals = new Double[lines.Length]; Double[] yVals = new Double[lines.Length]; int i = 0; foreach (string inputRecord in lines) { string[] inputTokens = inputRecord.Split(','); xVals[i] = Convert.ToDouble(inputTokens[0]); yVals[i] = Convert.ToDouble(inputTokens[1]); i++; } this.cacheDemandCurvePoints = new CacheCurvePoints(xVals, yVals); //this.cacheDemandFunc = Interpolate.LinearBetweenPoints(this.cacheDemandCurvePoints.xVals, this.cacheDemandCurvePoints.yVals); //this.cacheDemandFunc = Interpolate.Linear(this.cacheDemandCurvePoints.xVals, this.cacheDemandCurvePoints.yVals); this.cacheDemandFunc = Interpolate.PolynomialEquidistant(this.cacheDemandCurvePoints.xVals, this.cacheDemandCurvePoints.yVals); }
//================================================================ //Methodes //================================================================ public void BuildAnimation(IInterpolation interpolation, double duration) { if (NeedBuidAnimation) { byte direction = Direction; switch (direction) { case LEFT_RIGHT: for (int i = 0; i < countchildren; i++) { if (childrens[i].NeedBuildUI) { continue; } if (!childrens[i].IgnoreUpdate && !(childrens[i] is Text)) { float x = -childrens[i].Width; MoveXModifier modifier = new MoveXModifier(duration, x, childrens[i].Position.X, null, interpolation); childrens[i].RegisterModifier(modifier); } } break; case RIGHT_LEFT: for (int i = 0; i < countchildren; i++) { if (childrens[i].NeedBuildUI) { continue; } if (!childrens[i].IgnoreUpdate && !(childrens[i] is Text)) { float x = camera.width; MoveXModifier modifier = new MoveXModifier(duration, x, childrens[i].Position.X, null, interpolation); childrens[i].RegisterModifier(modifier); } } break; case TOP_BOTTOM: for (int i = 0; i < countchildren; i++) { if (childrens[i].NeedBuildUI) { continue; } if (!childrens[i].IgnoreUpdate && !(childrens[i] is Text)) { float y = -childrens[i].Height; MoveYModifier modifier = new MoveYModifier(duration, y, childrens[i].Position.Y, null, interpolation); childrens[i].RegisterModifier(modifier); } } break; case BOTTOM_TOP: for (int i = 0; i < countchildren; i++) { if (childrens[i].NeedBuildUI) { continue; } if (!childrens[i].IgnoreUpdate && !(childrens[i] is Text)) { float y = camera.height; MoveYModifier modifier = new MoveYModifier(duration, y, childrens[i].Position.Y, null, interpolation); childrens[i].RegisterModifier(modifier); } } break; case MIX_HORIZONTAL: break; case MIX_VERTICAL: break; default: break; } } }
public TransformedInterpolation(IInterpolation interpolation, Func<double, double> transform) { _interpolation = interpolation; _transform = transform; }
/// <summary> /// Initializes a new instance of the <see cref="LcImsPeptideSearchWorkfow"/> class. /// </summary> /// <param name="uimfFileLocation"> /// The uimf file location. /// </param> /// <param name="parameters"> /// The parameters. /// </param> /// <param name="netAlignment"> /// The net alignment. /// </param> public LcImsPeptideSearchWorkfow(string uimfFileLocation, LcImsPeptideSearchParameters parameters, IInterpolation netAlignment) : this(uimfFileLocation, parameters) { this._netAlignment = netAlignment; }
public MoveModifier(double duration, Vector2 from, Vector2 to, IEntityModifierListener listener, IInterpolation function) : this(duration, from.X, to.X, from.Y, to.Y, listener, function) { }
public PathModifier(float pDuration, IEntity entity, Path path, IEntityModifierListener entityModiferListener, IInterpolation function) : base(entityModiferListener) { int pathSize = path.Size(); if (pathSize < 2) { throw new Exception("Path needs at least 2 waypoints!"); } this.entity = entity; this.path = path; MoveModifier[] moveModifiers = new MoveModifier[pathSize - 1]; float[] coordinatesX = path.CoordinatesX(); float[] coordinatesY = path.CoordinatesY(); float velocity = path.Length() / pDuration; int modifierCount = moveModifiers.Length; for (int i = 0; i < modifierCount; i++) { float duration = path.SegmentLength(i) / velocity; moveModifiers[i] = new MoveModifier(duration, coordinatesX[i], coordinatesX[i + 1], coordinatesY[i], coordinatesY[i + 1], null, function); } /* Create a new SequenceModifier and register the listeners that * call through to mEntityModifierListener and mPathModifierListener. */ sequenceModifier = new SequenceModifier<IEntity>(moveModifiers); sequenceModifier.StartSequenceAction += (sender => SequenceStarted()); sequenceModifier.FinishSequenceAction += (sender => SequenceFinished()); sequenceModifier.StartModifierAction += (sender => SequenceListenerStarted(this.entity)); sequenceModifier.FinishModifierAction += (sender => SequenceListenerFinished(this.entity)); }