Beispiel #1
0
 public Länge Y(Länge x)
 {
     return(Länge.FromMeter(
                Wurfparabel.Y(
                    x: x.Meter / Scale,
                    v0: AbsprungGeschwindigkeit.MeterProSekunde,
                    alpha: AbsprungWinkel.Rad,
                    y0: _absprungHöhe.Meter) * Scale));
 }
Beispiel #2
0
 public override int GetHashCode()
 {
     return(ZimmerNummer.GetHashCode()
            ^ Besucher.GetHashCode()
            ^ Länge.GetHashCode()
            ^ Breite.GetHashCode()
            ^ Stock.GetHashCode()
            ^ MaxStoecke.GetHashCode());
 }
Beispiel #3
0
 Schanze(Länge länge,
         Länge höhe,
         Winkel absprungwinkel,
         Länge radius, double scale)
 {
     _länge         = länge;
     _höhe          = höhe;
     Absprungwinkel = absprungwinkel;
     _radius        = radius;
     Scale          = scale;
 }
Beispiel #4
0
        public static Schanze Create(Länge höhe, Winkel absprungwinkel)
        {
            var radius = höhe.Meter / (1 - Math.Cos(absprungwinkel.Rad));
            var länge  = radius * Math.Sin(absprungwinkel.Rad);

            return(new Schanze(
                       länge: Länge.FromMeter(länge),
                       höhe: höhe,
                       absprungwinkel: absprungwinkel,
                       radius: Länge.FromMeter(radius),
                       scale: 1
                       ));
        }
Beispiel #5
0
        public void Test1()
        {
            var winkel     = Winkel.FromDeg(19);
            var höhe       = Länge.FromCentimeter(16);
            var berechnung = Schanze.Create(höhe, winkel);

            Assert.That(berechnung, Is.Not.Null);
            Assert.That(berechnung.Höhe.Meter, Is.EqualTo(höhe.Meter));
            Assert.That(berechnung.Absprungwinkel.Rad, Is.EqualTo(winkel.Rad));
            Assert.That(berechnung.Absprungwinkel.Deg, Is.EqualTo(winkel.Deg));
            Assert.That(berechnung.Länge.Meter, Is.EqualTo(0.956).Within(0.001));
            Assert.That(berechnung.Radius.Meter, Is.EqualTo(2.936).Within(0.001));
        }
Beispiel #6
0
        private void OnBerechnenClick(object sender, RoutedEventArgs e)
        {
            try {
                var winkel          = Winkel.FromDeg(double.Parse(AbsprungWinkelTextBox.Text));
                var geschwindigkeit = Geschwindigkeit.FromKilometerProStunde(double.Parse(AbsprungGeschwindigkeitTextBox.Text));
                var schanzenHöhe    = Länge.FromCentimeter(double.Parse(AbsprungHöheTextBox.Text));

                var schanze  = Schanze.Create(schanzenHöhe, winkel);
                var flugbahn = Flugbahn.Create(schanze, geschwindigkeit);
                var setting  = SettingViewModel.Create(schanze, flugbahn);

                _viewModel.Settings.Add(setting);
                _viewModel.SelectedSetting = setting;
            } catch (Exception) {
                // TODO Fehler visualisieren
            }
        }
Beispiel #7
0
        public static Flugbahn Create(
            Schanze schanze,
            Geschwindigkeit absprungGeschwindigkeit)
        {
            var weite = Wurfparabel.Weite(
                v0: absprungGeschwindigkeit.MeterProSekunde,
                y0: schanze.Höhe.Meter,
                alpha: schanze.Absprungwinkel.Rad);

            var scheitelpunktX = Wurfparabel.ScheitelpunktX(
                v0: absprungGeschwindigkeit.MeterProSekunde,
                y0: schanze.Höhe.Meter,
                alpha: schanze.Absprungwinkel.Rad
                );

            var höhe = Wurfparabel.ScheitelpunktY(
                v0: absprungGeschwindigkeit.MeterProSekunde,
                y0: schanze.Höhe.Meter,
                alpha: schanze.Absprungwinkel.Rad);

            var aufprallWinkel = Wurfparabel.AufprallWinkel(
                v0: absprungGeschwindigkeit.MeterProSekunde,
                y0: schanze.Höhe.Meter,
                alpha: schanze.Absprungwinkel.Rad
                );

            var aufprallGeschwindigkeit = Wurfparabel.AufprallGeschwindigkeit(
                v0: absprungGeschwindigkeit.MeterProSekunde,
                y0: schanze.Höhe.Meter,
                alpha: schanze.Absprungwinkel.Rad
                );

            return(new Flugbahn(
                       absprungHöhe: schanze.Höhe,
                       absprungWinkel: schanze.Absprungwinkel,
                       absprungGeschwindigkeit: absprungGeschwindigkeit,
                       sprungWeite: Länge.FromMeter(weite),
                       scheitelpunktX: Länge.FromMeter(scheitelpunktX),
                       scheitelpunktY: Länge.FromMeter(höhe),
                       aufprallWinkel: Winkel.FromRad(aufprallWinkel),
                       aufprallGeschwindigkeit: Geschwindigkeit.FromMeterProSekunde(aufprallGeschwindigkeit),
                       scale: 1));
        }
Beispiel #8
0
 Flugbahn(Länge absprungHöhe,
          Winkel absprungWinkel,
          Geschwindigkeit absprungGeschwindigkeit,
          Länge sprungWeite,
          Länge scheitelpunktX,
          Länge scheitelpunktY,
          Winkel aufprallWinkel,
          Geschwindigkeit aufprallGeschwindigkeit,
          double scale)
 {
     _absprungHöhe           = absprungHöhe;
     AbsprungWinkel          = absprungWinkel;
     AbsprungGeschwindigkeit = absprungGeschwindigkeit;
     _sprungWeite            = sprungWeite;
     _scheitelpunktY         = scheitelpunktY;
     _scheitelpunktX         = scheitelpunktX;
     Scale                   = scale;
     AufprallWinkel          = aufprallWinkel;
     AufprallGeschwindigkeit = aufprallGeschwindigkeit;
 }
Beispiel #9
0
        public SceneViewModel()
        {
            _settings = new ObservableCollection <SettingViewModel>();
            _settings.CollectionChanged += OnSettingCollectionChanged;

            if (DesignerProperties.GetIsInDesignMode(new DependencyObject()))
            {
                var winkel          = Winkel.FromDeg(22);
                var geschwindigkeit = Geschwindigkeit.FromKilometerProStunde(20);
                var schanzenHöhe    = Länge.FromCentimeter(16);

                var schanze  = Berechnung.Schanze.Create(schanzenHöhe, winkel);
                var flugbahn = Berechnung.Flugbahn.Create(schanze, geschwindigkeit);

                var model = new SettingViewModel(schanze, flugbahn)
                {
                    RenderMetrics = true
                };
                Settings.Add(model);
            }
        }
Beispiel #10
0
 static Point ToPoint(Länge x, Länge y) => new Point(x.Meter, y.Meter);
Beispiel #11
0
        public FlugbahnViewModel(Schanze schanze, Flugbahn flugbahn)
        {
            _flugbahn = flugbahn ?? throw new ArgumentNullException(nameof(flugbahn));

            var punkte   = new List <Point>();
            var segments = 100;
            var step     = (int)flugbahn.SprungWeite.Meter / segments;

            // Horizontaler Offset, wenn Schanze vorhanden
            var x0 = schanze?.Länge ?? Länge.Empty;

            // Absprungpunkt
            var x = Länge.Empty;
            var y = flugbahn.Y(x);

            StartPunkt = ToPoint(x0 + x, y);
            punkte.Add(StartPunkt);

            // Bahnpunkte
            for (int i = 1; i <= segments; i++)
            {
                x = Länge.FromMeter(i * step);
                y = flugbahn.Y(x);

                punkte.Add(ToPoint(x0 + x, y));
            }

            // Aufprallpunkt
            x = flugbahn.SprungWeite;
            y = flugbahn.Y(x);

            EndPunkt = ToPoint(x0 + x, y);
            punkte.Add(EndPunkt);

            Punkte = new PointCollection(punkte);

            Scheitelpunkt = ToPoint(x0 + flugbahn.ScheitelpunktX, flugbahn.ScheitelpunktY);

            var winkelSize     = flugbahn.Scale * 0.2;
            var tangentenLänge = flugbahn.Scale;
            // Absprung
            var m = Matrix.Identity;

            m.Rotate(flugbahn.AbsprungWinkel.Deg);

            var v = new Vector(tangentenLänge, 0);

            AbsprungTangentenKontrollpunkt1 = StartPunkt + v;
            AbsprungTangentenKontrollpunkt2 = StartPunkt + v * m;

            v = new Vector(winkelSize, 0);

            AbsprungWinkelPunkt1 = StartPunkt + v;
            AbsprungWinkelPunkt2 = StartPunkt + v * m;
            AbsprungWinkelSize   = new Size(winkelSize, winkelSize);

            // Aufprall
            m = Matrix.Identity;
            m.Rotate(-flugbahn.AufprallWinkel.Deg);

            v = new Vector(-tangentenLänge, 0);

            AufprallTangentenKontrollpunkt1 = EndPunkt + v;
            AufprallTangentenKontrollpunkt2 = EndPunkt + v * m;

            v = new Vector(-winkelSize, 0);

            AufprallWinkelPunkt1 = EndPunkt + v;
            AufprallWinkelPunkt2 = EndPunkt + v * m;
            AufprallWinkelSize   = new Size(winkelSize, winkelSize);
        }