/// <summary>
/// Nächsten Polygonpunkt zusammen mit einer Farbe definieren
/// </summary>
/// <param name="P"></param>
/// <param name="color"></param>
/// <returns></returns>
public bool LineTo(Euk.Vector P, Css.Color color)
{
Debug.Assert(P.Dimensions == 2);
polygon.Add(new Euk.Vector(P));
colors.Add(color);
return(true);
}
/// <summary>
/// Dreieck, definiert durch drei Eckpunkte
/// </summary>
/// <param name="P0"></param>
/// <param name="P1"></param>
/// <param name="P2"></param>
public Triangle(Ekd.Vector P0, Ekd.Vector P1, Ekd.Vector P2, Brush brush, Pen pen)
: base(brush, pen)
{
Corner0 = new Ekd.Vector(P0);
Corner1 = new Ekd.Vector(P1);
Corner2 = new Ekd.Vector(P2);
}
/// <summary>
/// Dreieck, definiert durch die Schnittpunkte dreier Linien
/// </summary>
/// <param name="line0"></param>
/// <param name="line1"></param>
/// <param name="line2"></param>
public Triangle(Ekd.Line line0, Ekd.Line line1, Ekd.Line line2, double Epsilon, Brush brush, Pen pen)
: base(brush, pen)
{
Debug.Assert(line0.Dimensions == 2);
Debug.Assert(line1.Dimensions == 2);
Debug.Assert(line2.Dimensions == 2);
Ekd.Vector corn0;
if (!line0.IntersectionWith(line1, out corn0))
{
throw new ArgumentException();
}
Ekd.Vector corn1;
if (!line1.IntersectionWith(line2, out corn1))
{
throw new ArgumentException();
}
Ekd.Vector corn2;
if (!line2.IntersectionWith(line0, out corn2))
{
throw new ArgumentException();
}
Corner0 = corn0;
Corner1 = corn1;
Corner2 = corn2;
}
/// <summary>
/// Startpunkt eines Polygons definieren
/// </summary>
/// <param name="P"></param>
/// <returns></returns>
public bool StartsAt(Euk.Vector P)
{
Debug.Assert(P.Dimensions == 2);
polygon.Clear();
polygon.Add(new Euk.Vector(P));
return(true);
}
bool Translate(Euk.Vector displacement)
{
var trafo = new Euk.Transformations.Translation(displacement);
int i = 0;
Edges = Edges.Select(e => Edges[i++] = new Euk.Line(e, trafo)).ToArray();
return(true);
}
public Trapez(Ekd.Vector P0, Ekd.Vector P1, Ekd.Vector P2, Ekd.Vector P3, Brush brush, Pen pen)
: base(brush, pen)
{
Corner0 = new Ekd.Vector(P0);
Corner1 = new Ekd.Vector(P1);
Corner2 = new Ekd.Vector(P2);
Corner3 = new Ekd.Vector(P3);
}
public static void Create(E.Vector Pos, Models.Polygon Model, GphW3.CanvasPlotter Plotter)
{
Model.PolygonBlock.Clear();
Model.StartsAt(new E.Vector(0, 0) + Pos);
Model.LineTo(new E.Vector(100, 0) + Pos);
Model.LineTo(new E.Vector(100, 100) + Pos);
Model.LineTo(new E.Vector(0, 100) + Pos);
Model.LineTo(new E.Vector(0, 0) + Pos);
Model.LineTo(new E.Vector(100, 100) + Pos);
Model.PolygonBlock.draw(Plotter);
}
public static void Create(double Vergrößerungsfaktor, Models.Polygon Model, GphW3.CanvasPlotter Plotter)
{
var v = new E.Vector(500, 400);
Model.Clear();
Model.StartsAt(v);
Css.Color[] colors = { Css.Color.Green, Css.Color.Lime, Css.Color.Orange, Css.Color.Aqua };
for (int phi = 0, ci = 0; phi < 360; phi += 4, ci++)
{
var vs = new E.Vector(100, 0);
var rot = new E.Transformations.RotationInCylindricalCoordinates(2, phi * Math.PI / 180.0, 0, 1);
var scale = new E.Transformations.Scale(Vergrößerungsfaktor * phi / 360.0, 1);
var vrand = rot.apply(scale.apply(vs)) + v;
Model.LineTo(vrand, colors[ci % colors.Length]);
}
Model.PolygonBlock.draw(Plotter);
}
/// <summary>
/// Nächsten Polygonpunkt definieren
/// </summary>
/// <param name="P"></param>
/// <returns></returns>
public bool LineTo(Euk.Vector P)
{
Debug.Assert(P.Dimensions == 2);
polygon.Add(new Euk.Vector(P));
return(true);
}
public Line(Ekd.Line line, Brush brush, Pen pen)
: base(brush, pen)
{
P1 = new Ekd.Vector(line.P1);
P2 = new Ekd.Vector(line.P2);
}
public Line(Ekd.Line line, double factP1, double factP2, Brush brush, Pen pen)
: base(brush, pen)
{
P1 = new Ekd.Vector(line.P1 + (line.Direction * factP1));
P2 = new Ekd.Vector(line.P2 + (line.Direction * factP2));
}
public VelocityInMilesPerHour(E.Vector V) : base(V.coordinates)
{
}
public Line(Ekd.Vector P1, Ekd.Vector P2, Brush brush, Pen pen)
: base(brush, pen)
{
this.P1 = new Ekd.Vector(P1);
this.P2 = new Ekd.Vector(P2);
}
/// <summary>
/// Konstruktor, der einen 0- Vektor mit Coordinatenangaben in der Basiseinheit erzeugt
/// </summary>
/// <param name="dimensions"></param>
protected MeasuredValuesVector(int dimensions)
{
_unit = (new TMeasuredValue()).BaseUnit;
_vector = new E.Vector(dimensions);
}
public Velocities(MeasuredValueV.UnitV unit, E.Vector Vector) : base(unit, Vector)
{
}
public static AccelerationInMeterPerSec <Mag.Centi> CentimeterPerSec2(E.Vector V)
{
return(CentimeterPerSec2(V.coordinates));
}
//public abstract MeasuredValuesVector<TMeasuredValue, TUnit> Create();
//public abstract MeasuredValuesVector<TMeasuredValue, TUnit> Create(int dimensions);
//public abstract MeasuredValuesVector<TMeasuredValue, TUnit> Create(TUnit unit, int dimensions);
/// <summary>
/// Copy- Konstruktor
/// </summary>
/// <param name="v"></param>
protected MeasuredValuesVector(MeasuredValuesVector <TMeasuredValue, TUnit> v)
{
_unit = v.Unit;
_vector = new E.Vector(v.Vector);
}
public Velocity(E.Vector V) : base(V.coordinates)
{
}
/// <summary>
/// Konstruktoren, der einen 0- Vektor erzeugt.
/// </summary>
/// <param name="unit">Maßeinheit, auf die sich die numerischen Koordinaten beziehen</param>
/// <param name="dimensions">Anzahl der Dimensionen</param>
protected MeasuredValuesVector(TUnit unit, int dimensions)
{
_unit = unit;
_vector = new E.Vector(dimensions);
}
//public abstract MeasuredValuesVector<TMeasuredValue, TUnit> Create(TUnit unit, params double[] values);
/// <summary>
/// Konstruktor, der eine übergebene Liste von Messwerten in die im ersten Parameter
/// übergebene Einheit umrechnet und als Koordinaten eines Vektors speichert.
/// </summary>
/// <param name="unit">Maßeinheit, auf die sich die numerischen Koordinaten beziehen</param>
/// <param name="values">Liste der Koordinaten als Messwerte in individuellen Einheiten</param>
protected MeasuredValuesVector(TUnit unit, params mko.Newton.MeasuredValue <TUnit>[] values)
{
Debug.Assert(values.Length > 0);
_unit = unit;
_vector = new E.Vector(values.Select(m => m.ConvertTo(unit)).ToArray());
}
/// <summary>
/// Konstruktor, mit dem ein Existierender Vector mit einer Unit dekoriert wird
/// </summary>
/// <param name="unit">Maßeinheit, auf die sich die numerischen Koordinaten beziehen, </param>
/// <param name="Vector">Vektor mit Coordinaten</param>
protected MeasuredValuesVector(TUnit unit, E.Vector Vector)
{
_unit = unit;
_vector = Vector;
}
/// <summary>
/// Konstruktor, der für eine übergebenen Liste von Werten und der übergebenen Einheit
/// einen Vektor erzeugt
/// </summary>
/// <param name="unit">Maßeinheit, auf die sich die numerischen Koordinaten beziehen</param>
/// <param name="values">Liste der Koordinaten</param>
protected MeasuredValuesVector(TMeasuredValue MasterValue, params double[] values)
{
Debug.Assert(values.Length > 0);
this.MasterValue = MasterValue;
_vector = new E.Vector(values);
}
/// <summary>
/// Seiteninhalt programatisch aufbauen
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Page_Init(object sender, EventArgs e)
{
Model = mkoIt.Asp.PageState <Models.Polygon> .Create(Session);
//var phld1 = sender as PlaceHolder;
phld1.Controls.Add(
new mkoIt.Asp.HtmlCtrl.DIV(
new Htm.Button("btnCreateSpiral", out btnCreateSpiral)
{
Text = "Spirale erzeugen",
SetClick = (s, args) =>
{
double Vergrößerungsfaktor;
if (double.TryParse(tbx.Text, out Vergrößerungsfaktor))
{
SpiralFactory.Create(Vergrößerungsfaktor, Model, Plotter);
}
}
},
new Htm.TextBox("tbxSpiralFactor", out tbx)
{
Text = "2",
ToolTip = "Vergrößerungsfaktor der Spirale",
CssStyleBld = new Css.StyleBuilder()
{
Width = new Css.LengthPixel(30),
TextAlign = Css.TextAlign.Right,
BackgroundColor = Css.Color.Aqua
}
},
new Htm.Button("btnCreateTrapez", out btnCreateTrapez)
{
Text = "Trapez Erzeugen",
SetClick = (s, args) =>
{
}
},
new Htm.Button("btnCreateHausNiko", out btnCreateNikohome)
{
Text = "Haus von Nikolaus",
SetClick = (s, args) =>
{
Model.Clear();
Css.Color[] colors = { Css.Color.Lime, Css.Color.Red, Css.Color.Blue };
int cs = 0;
for (double a = 0.0; a < 2 * Math.PI; a += 2 * Math.PI / 20.0, cs++)
{
Model.DefaultColor = colors[cs % colors.Length];
var Pos = new E.Vector(a * 200.0, Math.Sin(a) * 300);
NikoHomeFactory.Create(new E.Vector(100, 300) + Pos, Model, Plotter);
}
}
},
new Htm.BR(),
new Htm.Canvas("canMain", out canMain)
{
Width = 1500,
Height = 800
}
)
{
CssStyleBld = new Css.StyleBuilder()
{
BackgroundColor = Css.Color.Black,
BorderStyle = Css.BorderStyle.Inset
}
}
);
Plotter = new mko.Graphic.WebClient.CanvasPlotter(new Htm.Canvas.ClientComponentScriptBld(canMain.ClientID));
}
public static AccelerationInMeterPerSec <Mag.Kilo> KilometerPerSec2(E.Vector V)
{
return(KilometerPerSec2(V.coordinates));
}
public static AccelerationInMeterPerSec <Mag.One> MeterPerSec2(E.Vector V)
{
return(MeterPerSec2(V.coordinates));
}
protected virtual void CreateVector(params double[] Coordinates)
{
_vector = new E.Vector(Coordinates);
}
protected virtual void CreateVector(int Dimension)
{
_vector = new E.Vector(Dimension);
}
public static E.Vector ToOne(E.Vector Vector, OrderOfMagnitudeEnum FromOofM)
{
double f = OrderOfMagnitudeFactor[FromOofM];
return(new E.Vector(Vector.coordinates.Select(c => c * f).ToArray()));
}
public Accelerations(MeasuredValueAcc.UnitAcc unit, E.Vector Vector) : base(unit, Vector)
{
}
public static E.Vector FromTo(E.Vector Vector, OrderOfMagnitudeEnum From, OrderOfMagnitudeEnum To)
{
double f = OrderOfMagnitudeFactor[From] / OrderOfMagnitudeFactor[To];
return(new E.Vector(Vector.coordinates.Select(c => c * f).ToArray()));
}
