Die Zeichenfläche (Canvas) hat ein Koordinatensystem, welches den Ursprung oben links hat. Die Y-Achse schaut also nach unten. Ein solches Koordinatensystem ist für das Zeichnen von Graphen unpraktisch. Daher übernimmt das JSG-Modul die Abbildungstransformation von geeigneten Weltkoordinaten (Window-Koordinaten genannt) in Canvas-Koordinaten (siehe auch JSG: Abbildung).

Die Abbildungs-Transformationen werden durch das Definieren von zwei Wertebereichen festgelegt:

• Der Viewport legt den Zielbereich in Canvas-Koordinaten fest (siehe SetViewport()).
• Das Window legt den im Zielbereich abzubildenden Wertebereich in Welt-Koordinaten fest (siehe SetWindow()).

Die Abbildungs-Transformationen werden so berechnet, dass jeder Punkt des Windows vollständig innerhalb des zugehörigen Viewports liegt. Es kann eingestellt werden, ob am Viewport-Rand geclippt werden soll oder nicht. Am Canvas-Rand wird immer geclippt.

JsGraph.SetViewport()

JsGraph.SetViewport( X, Y, Width, Height, ScaleArgs, Clip )
JsGraph.SetViewport( Left, Top, Right, Bottom, ScaleArgs, Clip )

X, Y: Number(>=0); Optional; Default = (0,0)

Ursprung (links, oben) des Viewports bezüglich des Canvas Nullpunktes in Pixel. Der Canvas Nullpunkt ist das erste Pixel links oben des Canvas-Elementes. Beachte: positive X-Werte liegen rechts vom Nullpunkt, positive Y-Werte liegen unterhalb vom Nullpunkt.

Width, Height: Number(>=0); Optional; Default = (CanvasWidth, CanvasHeight)

Breite und Höhe des Viewports in Pixel. Wird einer dieser Parameter nicht angegeben oder 0 gesetzt, so wird an seiner Stelle der enstprechende Canvas-Wert CanvasWidth bzw. CanvasHeight abzüglich X bzw. Y genommen.

Left, Top: Number(>=0)

Ursprung (links, oben) des Viewports bezüglich des Canvas Nullpunktes in Pixel, wie X und Y.

Right, Bottom: Number(<0)

Abstand vom rechten bzw. unteren Rand in Pixel.

ScaleArgs: Boolean; Optional; Default = false

true → Skaliert X, Y, Left, Top, Right, Bottom mit ScalePix()

Clip: Boolean; Optional; Default = false

true → Setzt den Clipping-Bereich auf den Viewport-Bereich

Setzt den Viewport auf den mit den Parametern angegeben Bereich und Setzt das Window so, dass es eine 1:1 Abbildung in diesen Viewport macht, wobei der Nullpunkt unten Links im Viewport zu liegen kommt. Dies wird intern durch folgenden Aufruf erreicht:

jsg.SetWindow( 0, 0, jsg.VpInnerWidth, jsg.VpInnerHeight );

Jeder Canvas hat zu einer bestimmten Zeit genau einen Viewport. Dieser kann jedoch nacheinander auf verschiedene Bereiche gesetzt werden. Beim Erzeugen eines Canvas mit dem JsGraph Konstruktor wird der Viewport auf den ganzen Canvas-Bereich gesetzt. Um einen geänderten Viewport wieder auf den ganzen Canvas-Bereich zurückzusetzen, kann SetViewport() ohne Parameter aufgerufen werden:

jsg.SetViewport();

Die Parameter dieser Funktion können ungerade Zahlen sein, was insbesondere intern resultiert, wenn ScaleArgs = true ist. Wenn Pixel-genaues Zeichnen erwünscht ist, muss ScalePix = false gesetzt sein und die Parameter müssen ganze Zahlen sein.

Der Viewport-Bereich kann so gesetzt werden, dass er über den Canvas hinausragt. Dies wirkt sich auf die Abbildungs-Transformation entsprechend aus. Die Grafik wird jedoch am Canvas-Rand geclippt.

Wenn ScaleArgs = true werden die Argumente X, Y, Left, Top, Right, Bottom mit der Funktion ScalePix() skaliert. Dies ist insbesondere bei der zweiten Aufrufvariante sinnvoll, wenn der Rand zwischen Canvas und Viewport sich mit der Grösse des Canvas proportional ändert soll. Die zweite Aufrufvariante entspricht dem Aufruf von SetViewportRel().

Wenn auf einem Canvas mehrere Viewports mit Rändern gezeichnet werden sollen, kombiniert man SetViewport() am besten mit SetViewportRel():

// Viewport auf der linken Hälfte des Canvas
jsg.SetViewport( 0, 0, jsg.CanvasWidth/2, jsg.CanvasHeight );

// Viewport um margin verkleinern und Clipping auf diesen Bereich setzen
jsg.SetViewportRel( margin );

// Window setzen und Grafik zeichnen
  :

// Viewport auf der rechten Hälfte des Canvas
jsg.SetViewport( 0, jsg.CanvasWidth/2, jsg.CanvasWidth/2, jsg.CanvasHeight );

// Viewport um margin verkleinern und Clipping auf diesen Bereich setzen
jsg.SetViewportRel( margin );

// Window setzen und Grafik zeichnen
  :

Wenn die Grafik am Viewport-Rand geclippt werden soll, kann Clip = true gesetzt werden. Wenn Clip = false oder undefiniert ist, wird der Clipping-Bereich auf den Canvas-Bereich gesetzt.

Siehe auch SetClipping() und SetGraphClipping().

JsGraph.SetViewportRel()

JsGraph.SetViewportRel( Left, Top, Right, Bottom, ScaleArgs, Clip )

Left: Integer(>=0); Optional; Default = 0

Linker Rand zwischen dem alten äusseren Viewport und dem neuen inneren Viewport in Pixeln

Top: Integer(>=0); Optional; Default = Left

Oberer Rand zwischen dem alten äusseren Viewport und dem neuen inneren Viewport in Pixeln

Right: Integer(>=0); Optional; Default = Left

Rechter Rand zwischen dem alten äusseren Viewport und dem neuen inneren Viewport in Pixeln

Bottom: Integer(>=0); Optional; Default = Top

Unterer Rand zwischen dem alten äusseren Viewport und dem neuen inneren Viewport in Pixeln

ScaleArgs: Boolean; Optional; Default = true

true → Skaliert alle Argumente mit der Funktion ScalePix()

Clip: Boolean; Optional; Default = true

true → Setzt den Clipping-Bereich auf den Viewport-Bereich

Mit SetViewportRel kann der aktuelle Viewport verkleinert werden, indem man die Grösse der vier Ränder angibt. Die Randgrössen werden Standardmässig mit der Funktion ScalePix() skaliert (wenn das Argument ScaleArgs = true ist). Die Rahmenbreite skaliert damit mit der Canvasgrösse.

Wenn die Grafik am Viewport-Rand geclippt werden soll, kann Clip = true gesetzt werden (Standardwert). Wenn Clip = false ist, wird der Clipping-Bereich auf den Canvas-Bereich gesetzt.

Siehe auch SetClipping() und SetGraphClipping().

Praktisch ist diese Funktion, wenn z.B. vier gleichmässig verteilte Grafiken innerhalb eines Canvas gezeichnet werden sollen, wobei jede Grafik einen Rahmen haben soll, der mit dem Canvas skaliert. In diesem Fall setzt man zunächt einen Viewport mit SetViewport() auf einen der vier Quadranten und verkleinert diesen dann mit SetViewportRel() um den gewünschten Rahmen. Dann zeichnet man die Grafik in diesen Bereich. Dies macht man hintereinander für jeden Quadranten.

// erster Quadrant
g.SetViewport( 0, 0, g.CanvasWidth/2, g.CanvasHeight/2 );
g.SetViewportRel( 20, 30, 10, 20, false, true );
g.SetWindow(....)
// Grafik im ersten Quadranten zeichnen
 :

// zweiter Quadrant
g.SetViewport( g.CanvasWidth/2, 0, g.CanvasWidth/2, g.CanvasHeight/2 );
g.SetViewportRel( 20, 30, 10, 20, false, true );
g.SetWindow(....)
// Grafik im zweiten Quadranten zeichnen
 :

JsGraph.SetWindow()

JsGraph.SetWindow( Xmin, Ymin, Xmax, Ymax )

Xmin, Ymin: Number; Optional; Default = (0,0)

Unterer Wertebereich für X- und Y-Achse des Windows in Weltkoordinaten.

Xmax, Ymax: Number; Optional; Default = (VpInnerWidth, VpInnerHeight)

Oberer Wertebereich für X- und Y-Achse des Windows in Weltkoordinaten.

Setzt die Abbildungs-Transformation von Welt-Koordinaten in aktuelle Viewport-Koordinaten. Beim Aufruf der Funktionen SetViewport() und SetViewportRel() bzw. nach dem Erzeugen des JsGraph Objektes wird die Window-Transformation wiefolgt gesetzt:

g.SetWindow();

was dem folgenden Aufruf entspricht:

g.SetWindow( 0, 0, g.VpInnerWidth, g.VpInnerHeight );

Dies entspricht einer 1:1 Abbildung von Welt- in Viewport-Koordinaten. Beachte folgende Unterschiede zwischen den Koordinatensystemen:

Alles, was innerhalb von Xmin-0.5px bis Xmax+0.5px und innerhalb von Ymin-0.5px und Ymax+0.5px gezeichnet wird, erscheint zumindest Teilweise innerhalb des Viewports. Ein Rechteck mit einer Strichdicke von 1 Pixel, das mit folgendem Aufruf gezeichnet wird, setzt genau die ersten und letzten Pixel innerhalb des aktuellen Viewport-Bereiches, siehe Abbildungen und Transformationen:

jsg.SetWindow( 0, 0, 1, 1 );
jsg.Rect( 0, 0, 1, 1 );

Achtung: Wenn bei den Argumenten Xmin > Xmax oder Ymin > Ymax angegeben wird, handelt es sich um eine Spiegel-Transformation. Der enstprechende Bereich wird gespiegel dargestellt.

Hinweise

Um in Viewport-Koordinaten zu zeichnen, muss man nicht extra ein Window mit einer Einheitstransformation definieren. Man wählt einfach mit SelectTrans() die Viewport-Transformation.

JsGraph.SetWindowWH()

JsGraph.SetWindowWH( Xmin, Ymin, Width, Height )

Xmin, Ymin: Number

Nullpunkt unten links des Windows in Weltkoordinaten.

Width: Number

Breite des Windows in Weltkoordinaten.

Height: Number

Höhe des Windows in Weltkoordinaten.

Wenn Width und/oder Height negativ sind, wird die entsprechende Achse gespiegelt. Bei ungespiegelten Achsen definieren Xmin und Ymin den linken unteren Punkt des Windows, bei gespiegelten Achsen den oberen rechten Punkt des Windows.

Wenn Width = 0 angegeben wird, wird die Window-Breite aufgrund der Window-Höhe so berechnet, dass eine unverzerrte Abbildung in den aktuellen Viewport entsteht.

Wenn Height = 0 angegeben wird, wird die Window-Höhe aufgrund der Window-Breite so berechnet, dass eine unverzerrte Abbildung in den aktuellen Viewport entsteht.

JsGraph.MapWindow()

JsGraph.MapWindow( Xcenter, Ycenter, Width, Height, Align )

Xcenter, Ycenter: Number

Zentrum des Windows in Weltkoordinaten.

Width: Number(>=0)

Breite des Windows in Weltkoordinaten.

Height: Number(>=0)

Höhe des Windows in Weltkoordinaten.

Align: Number(-1,0,1); Optional; Default = 0

Ausrichtung des Windows im Viewport, wenn das Seitenverhältnis ungleich ist.

Berechnet die Window-Koordinaten so, dass Xcenter und Ycenter in der Mitte des Viewport zu liegen kommen und eine unverzerrte Abbildung entsteht. Wird entweder Width oder Height gleich 0 gesetzt, wird die entsprechende Grösse aus dem Seitenverhältnis des Viewports berechnet und das Window wird im Viewport zentriert.

Wird sowohl Width als auch Height angegeben und ist das Seitenverhältnis von Window und Viewport ungleich, wird das Window so vergrössert, dass es genau in den Viewport passt. Dabei kann mit Align bestimmt werden, auf welcher Seite das Window vergrössert werden soll. Align = 0 zentriert das Window im Viewport. Align = - 1 richtet das Window links bzw. unten aus. Align = 1 richtet das Window rechts bzw. oben aus. Es sind auch Zwischenwerte erlaubt um das Window mehr oder weniger stark zu verschieben.

JsGraph.GetCanvasRect()

JsGraph.GetCanvasRect( )

Return: JsgRect

JsGraph.GetViewportRect()

JsGraph.GetViewportRect( )

Return: JsgRect

Gibt die Grösse des aktuellen Viewports als möglichst eng umschliessendes Rechteck zurück. Wenn die Viewport-Koordinaten keine ganzen Zahlen sind, wird das umschliessende Rechteck erweitert. Die Koordinaten des zurückgegebenen Rechtecks sind immer ganze Zahlen.

Diese Funktion wird zum Ermitteln des Rechtecks für die Funktion MakeSnapshot() verwendet.

JsGraph.SetClipping()

JsGraph.SetClipping( Range )

Range: String; Optional; Default = 'canvas'

Gültige Werte: undefiniert, 'window', 'viewport', 'canvas'

Setzt den Clipping-Bereich auf den mit Range angegebenen Bereich. Wenn Range nicht definiert oder ungültig ist, wird auf den 'canvas' Bereich geclippt.

Bei diesem Clipping handelt es sich um ein Clipping auf Pixel-Ebene, auch als Canvas-Clipping bezeichnet. Ein Clipping auf Grafik-Element-Ebene kann mit der Funktion SetGraphClipping() zusätzlich eingeschaltet werden.

JsGraph.SetGraphClipping()

JsGraph.SetGraphClipping( Clipping, Range, Extend )

Clipping: Boolean; Optional; Default = true

schaltet das Grafik-Clipping ein oder aus

Range: String; Optional; Default = 'canvas'

Gültige Werte: undefiniert, 'window', 'viewport', 'canvas'

Extend: Number; Optional

Neben dem Clipping auf Canvas-Ebene, welches mit SetClipping(), SetClipRect() oder Clip() definiert werden kann, gibt es auch Clipping auf Grafik-Element Ebene. Dieses Grafik-Clipping wird mit dieser Funktion aktiviert.

Ist das Grafik-Clipping aktiviert, werden die Grafik-Elemente selbst geclippt, bevor sie gerendert werden. Zusätzlich wird auch das Clipping auf Canvas-Ebene aktiviert. Das Grafik-Clipping ist dann sinnvoll, wenn Grafik den Zeichenbereich stark überschreitet. Dies kann z.B. bei Kreisen mit sehr grossen Radien der Fall sein. Die Canvas-Funktionen sind in diesem Fall oft überfordert, werden extrem langsam oder es entstehen sogar Darstellungsfehler.

Mit dem Einschalten des Grafik-Klipping werden die Elemente auf Grafik-Ebene geclippt und diese geclippten Elemente werden an die Canvas-Funktionen weitergereicht.

Das Grafik-Clipping ist so optimiert, dass es nur für Elemente verwendet wird, welche den normalen Clippbereich verlassen. Mit Extend kann dieser Clippbereich vergrössert werden. Ein Faktor von 1 vergrössert den Bereich um die Breite bzw. Höhe des Canvas. Damit wird erreicht, dass Elemente innerhalb dieses Bereiches nur per Canvas-Clipping geclippt werde, während das Grafik-Clipping erst für Elemente verwendet wird, welche diesen Bereich verlassen. Dies kann auf bestimmten Systemen performanter sein. Elemente die komplett ausserhalb des sichtbaren Bereiches liegen werden gar nicht erst gezeichnet.

Range gibt den Canvas-Clippingbereich an, wie er auch bei der Funktion SetClipping() definiert wird. Wenn Range nicht angegeben wird oder ein Leerstring ist, wird der Canvas-Clippingbereich nicht verändert.

Wenn Extend nicht angegeben wird, wird der aktuelle Wert (Default = 1) verwendet.

Hinweis: Der Grafik-Clippingbereich wird intern um die Strichdicke des jeweiligen Elementes vergrössert. Pixel, die dadurch ausserhalb des Clipping-Bereiches zu liegen kommen, werden vom Canvas-Clipping geclippt. Der Canvas-Clippingbereich kann mit Range festgelegt werden.

Mit der Funktion SetClipRect() oder Clip() können beliebige Canvas-Clippingbereiche definiert werden. Sollen so definierte Bereiche zusammen mit dem Grafik-Clipping verwendet werden, muss hier Range entweder nicht angegeben werden oder auf einen Leerstring gesetzt werden, damit der bereits definierte Canvas-Clippingbereich nicht verändert wird.

Siehe auch Properties GraphClipEnabled und GraphClipExtend.

JsGraph.SetClipRect()

JsGraph.SetClipRect( X, Y, Width, Height, Trans )

X, Y: Number

Ursprung (links, oben bei Canvas und Viewport; links unten bei Window) des Clipping-Bereichs im mit Trans gewählten Koordinatensystems.

Width, Height: Number

Breite und Höhe des Clipping-Bereiches.

Trans: String; Optional; Default = ''

Erlaubte Werte: 'window', 'viewport', 'canvas'

Setzt den Clipping-Bereich auf einen Rechteckigen Bereich. Wenn Trans nicht definiert ist, beziehen sich die Koordinaten auf das aktuelle Koordinatensystem (siehe Property Trans). Sonst kann mit Trans angegeben werden, in welchem System die Koordinaten sind.

Hinweis: Mit der Funktion Clip() können beliebig geformte Clipping-Bereiche gesetzt werden.

JsGraph.SelectTrans()

JsGraph.SelectTrans( Trans )

Trans: String; Optional; Default = 'window'

Gültige Werte: 'window', 'viewport', 'canvas'

Return: String

Gibt zurück, welche Transformation vor dem Aufruf aktiv war.

Die Koordinaten bei den Zeichen- und Abfragefunktionen beziehen sich auf ein bestimmtes Koordinatensystem. Mit SelectTrans kann das Koordinatensystem ausgewählt werden, das verwendet werden soll. Standardmässig ist das Window-Koordinatensystem aktiv. Die aktuell gewählte Transformation kann auch mit dem Property Trans ausgelesen werden.

JsGraph.ResetTrans()

JsGraph.ResetTrans( )

Return this: JsGraph

Setzt die Objekt-Transformation zurück, d.h. die Transformations-Matrix wird zur Einheitsmatrix.

Bevor Objekte gezeichnet werden, werden sie der Objekt-Transformation unterzogen. Damit können Objekte verschoben, skaliert, rotiert oder über eine beliebige Matrix verzerrt werden.

Die Transformations-Matrix kann zusammen mit den Attributen mit SaveAttrs() zwischengespeichert und mit RestoreAttrs() wieder abgerufen werden.

Es gibt folgende Funktionen, um die Transformations-Matrix zu modifizieren:

Die einzelnen Transformationen können mit obigen Funktionen kombiniert werden. Wenn man zum Beispiel ein Rechteck mit Breite 4 und Höhe 2 um seinen Mittelpunkt rotieren will, so kann man zunächst mit TransMove() das Rechteck um (-2, -1) so verschieben, dass sein Mittelpunkt bei Null zu liegen kommt. Dann kann mit TransRotate() das Rechteck um diesen Punkt gedeht werden. Schliesslich wird mit einem weiteren TransMove() das Rechteck-Zentrum an seine Endposition (200, 150) gesetzt:

g2d.TransMove( -2, -1 );
g2d.TransRotate( 30 );
g2d.TransMove( 200, 150 );
g2d.RectWH( 0, 0, 4, 2 );

Da die Transformations-Funktionen das JsGraph Objekt zurückgeben, können sie verkettet werden. Das folgende Beispiel ist identisch mit dem obigen:

g2d.TransMove( -2, -1 ).TransRotate( 30 ).TransMove( 200, 150 );
g2d.RectWH( 0, 0, 4, 2 );

JsGraph.SaveTrans()

JsGraph.SaveTrans( Reset )

Reset: Boolean; Optional; Default = false

true → ruft am Ende die Funktion ResetTrans() auf

Return: JsgTrans2D

Kopie der aktuellen Objekt-Transformation

Speichert eine Kopie der aktuelle Objekt-Transformation in einem internen Stack. Von dort kann diese Transformation mit RestoreTrans() wieder abgerufen und als aktuelle Transformation eingesetzt werden.

SaveTrans() gibt die Kopie der aktuellen Transformation zurück. Diese kann bei AddTrans() verwendet werden.

// aktuelle objekt transformation sichern und zurücksetzen
g.SaveTrans( true );

// neue transformationen setzen
g.TransRotate( winkel );
g.TransMove( x, y );

// etwas zeichnen
g.Polygon( ... );

// gesicherte Transformation wiederherstellen
g.RestoreTrans();

JsGraph.RestoreTrans()

JsGraph.RestoreTrans( )

Entfernt die zuletzt mit SaveTrans() auf dem Stack gespeicherte Objekt-Transformation von diesem und setzt sie als aktuelle Transformation ein. Wenn der Stack leer ist, macht diese Funktion nichts.

JsGraph.TransMove()

JsGraph.TransMove( x, y )
JsGraph.TransMove( p )

x, y: Number

Position zu der verschoben werden soll

p: JsgVect2

Position zu der verschoben werden soll

Return this: JsGraph

Addiert eine Verschiebung zur Objekt-Transformation.

JsGraph.TransScale()

JsGraph.TransScale( sx, sy )
JsGraph.TransScale( s )

sx, sy: Number

Skalierung in X- und Y-Richtung

s: JsgVect2

Skalierung in X- und Y-Richtung

Return this: JsGraph

Addiert eine Skalierung zur Objekt-Transformation.

JsGraph.TransRotate()

JsGraph.TransRotate( angle )

angle: Number

Rotations-Winkel

Return this: JsGraph

Addiert eine Rotation um den Nullpunkt zur Objekt-Transformation. Eine Rotation um einen beliebigen Punkt kann mit der Funktion TransRotateAtPoint() erreicht werden.

Je nach gewählter Window/Viewport-Transformation ist bei einem positiven Winkel die Rotation im Gegenuhrzeigersinn oder im Uhrzeigersinn. Bei einer Window-Transformation ohne Spiegelung einer Achse entspricht ein positivier Wert von angle dem Gegenuhrzeigersinn. Bei der Viewport- und Canvas-Transformation ist der Sinn umgekehrt.

JsGraph.TransRotateAtPoint()

JsGraph.TransRotateAtPoint( x, y, angle )
JsGraph.TransRotateAtPoint( p, angle )

x, y: Number

Punkt um den rotiert werden soll

p: JsgVect2

Punkt um den rotiert werden soll

angle: Number

Rotations-Winkel

Return this: JsGraph

Addiert eine Rotation um einen Punkt zur Objekt-Transformation. Im Vergleich zu TransRotate() kann hier eine beliebige Rotationsachse (x, y) angegeben werden.

Je nach gewählter Window/Viewport-Transformation ist bei einem positiven Winkel die Rotation im Gegenuhrzeigersinn oder im Uhrzeigersinn. Bei einer Window-Transformation ohne Spiegelung einer Achse entspricht ein positivier Wert von angle dem Gegenuhrzeigersinn. Bei der Viewport- und Canvas-Transformation ist der Sinn umgekehrt.

TransRotateAtPoint ist eine Kombination folgender Aufrufe:

1. TransMove()( -x, -y )
2. TransRotate()( angle )
3. TransMove()( x, y )

JsGraph.AddTrans()

JsGraph.AddTrans( Mat )
JsGraph.AddTrans( Trans )

Mat: array[3][2]

Transformations-Matrix

Trans: JsgTrans2D

eine Objekt-Transformation, wie sie die Funktion SaveTrans() liefert.

Return this: JsGraph

Addiert eine Transformation-Matrix oder eine Objekt-Transformation zur aktuellen Objekt-Transformation. Die Matrix muss aus mindestens 2x3 Elementen bestehen. Weitere Elemente werden ignoriert.

• Die Elemente Mat₀₀ und Mat₁₁ definieren die Skalierung in X- bzw. Y-Richtung.
• Die Elemente Mat₀₀, Mat₀₁, Mat₁₀ und Mat₁₁ definieren eine Scherung bzw. Rotation.
• Die Elemente Mat₀₂ und Mat₁₂ definieren die Verschiebung in X- bzw- Y-Richtung

JsGraph.SetAngleMeasure()

JsGraph.SetAngleMeasure( AngleUnit )

AngleUnit: String; Optional; Default = 'deg'

Winkel-Einheit 'deg' für Grad, 'rad' für Radiant

Return: String

vorheriger Wert von AngleMeasure

In den Zeichen- und Abfragefunktionen werden Winkel in Grad oder Radiant interpretiert bzw. ausgegeben. Mit SetAngleMeasure kann die gewünschte Winkel-Einheit eingestellt werden. Die aktuelle Einstellung kann aus dem Property AngleMeasure ausgelesen werden.

JsGraph.SetHighResolution()

JsGraph.SetHighResolution( OnOff )

OnOff: Boolean; Optional; Default = true

HighResolution-Modus

Return: Boolean

Alter Wert von HighResolution

Steuert, ob auf Retina-Displays mit der vollen Auflösung gezeichnet werden soll oder ob ein JSG-Pixel mehrere Bildschirm-Pixel gross sein soll.

Sogenannte Retina-Displays haben eine so hohe Pixeldichte, dass die 1:1 Darstellung von Website-Inhalten viel zu klein ausfallen würde. Daher werden pro Inhalt-Pixel mehrere Display-Pixel verwendet. Die Website wird also quasi z.B. doppelt so gross gezeichnet, als sie definiert ist. Texte und andere HTML-Elemente werden jedoch in der vollen Display-Auflösung gerendert, wodurch sie schärfer erscheinen.

Mit HighResolution kann eingestellt werden, ob auch das JSG-Modul die volle Auflösung des Displays nutzen soll und entsprechend scharfe Grafiken ausgeben soll. Dies braucht jedoch ein mehrfaches an Resourcen und kann bei dynamischen Inhalten besonders auf mobilen Geräten zu langsamen Darstellungen führen. Daher lässt sich dieser Modus mit HighResolution ein- und ausschalten. Ist er ausgeschaltet, wirkt die Grafik etwas verschwommen, was bei Animationen aber nicht auffällt. Standbilder sollten in der hohen Auflösung gerendert werden.

JsGraph.SetAutoScalePix()

JsGraph.SetAutoScalePix( AutoScalePix )

AutoScalePix: Boolean; Optional; Default = true

Return: Boolean

vorheriger Wert von AutoScalePix

Siehe SetScaleRef() für weitere Informationen.

JsGraph.SetLimitScalePix()

JsGraph.SetLimitScalePix( LimitScalePix )

LimitScalePix: Boolean; Optional; Default = true

Return: Boolean

vorheriger Wert von LimitScalePix

Siehe SetScaleRef() für weitere Informationen.

JsGraph.SetScalePixInt()

JsGraph.SetScalePixInt( ScalePixInt )

ScalePixInt: Boolean; Optional; Default = false

Return: Boolean

vorheriger Wert von ScalePixInt

Siehe SetScaleRef() für weitere Informationen.

JsGraph.SetScaleRef()

JsGraph.SetScaleRef( ScaleRef, LimitScalePix, AutoScalePix, ScalePixInt )
JsGraph.SetScaleRef( Params )

ScaleRef: Number(>0); Optional; Default = JsGraph.ScaleRef

Canvas Referenzbreite

LimitScalePix: Boolean; Optional; Default = JsGraph.LimitScalePix

true → die Skalierung wird nach oben limitert

AutoScalePix: Boolean; Optional; Default = JsGraph.AutoScalePix

true → bei Funktionen werden Pixelwerte Skaliert → ScalePix()

ScalePixInt: Boolean; Optional; Default = JsGraph.ScalePixInt

true → bei Funktionen werden Pixelwerte auf ganze Werte gerundet → ScalePix()

Params: JsgAttrsDef

Nur die enstprechenden Properties von Params werden verwendet

Die Funktionen ScalePix(), ScalePixI(), ScalePixMin(), ScalePixMinI(), ScalePixMax(), ScalePixMaxI(), ScalePixMinMax() und ScalePixMinMaxI() verwenden für die Skalierung von Pixelwerten die Referenzbreite ScaleRef.

Einige Grössenangaben wie LineWidth, TextSize und MarkerSize werden in Pixeln angegeben. Bei dynamischen Canvas, die sich der Fenstergrösse des Browsers anpassen, macht es Sinn, wenn sich die entsprechenden Objekte zusammen mit dem Canvas skalieren.

Es gibt zwei Methoden, dies zu erreichen: Alle Pixelwerte werden vor der Übergabe an Funktionen mit einer der oben aufgeführten Funktionen skaliert, oder man schaltet die automatische Skalierung mit AutoScalePix = true für alle Pixelwerte ein.

Für die Transformation muss eine Referenzbreite ScaleRef des Canvas definiert werden. Wenn der Canvas genau die Breite ScaleRef hat, werden Pixelwerte nicht verändert. Ist der aktuelle Canvas jedoch z.B. nur halb so breit wie ScaleRef, so werden alle Pixelgrössen halbiert. Ist der Canvas doppelt so breit wie ScaleRef, werden alle Pixelwerte verdoppelt, sofern LimitScalePix = false ist. Wenn LimitScalePix = true, werden Pixelwerte nur verkleinert, nicht jedoch vergrössert.

Anwendung von LimitScalePix: Eine Grafik werde für eine Canvasgrösse von 400 Pixeln optimiert gezeichnet: ScaleRef = 400. Nun wird dieser Canvas je nach Grösse des Browserfensters bis zu 800 Pixel breit. Wenn LimitScalePix = false ist, werden alle Pixelwerte verdoppelt: Striche werden doppelt so dick, Texte und Marker doppelt so gross usw. Dies sieht nicht schön aus, weil gegenüber dem Rest der Seite die Grafik so viel zu aufdringlich, fett wirkt. Wenn LimitScalePix = true ist, werden Pixelwerte nie vergrössert. Sie behalten ihren Designwert bei, wenn der Canvas breiter als 400 Pixel wird. Die Grafik selbst skaliert jedoch und wird doppelt so gross. Wird der Canvas hingegen kleiner als 400 Pixel, werden alle Pixelwerte und die Grafik proportional verkleinert.

Die zweite Aufrufvariante von SetScaleRef akzeptiert ein Objekt, z.B. ein JsgAttrsDef, in welchem die Parameter der ersten Variante definiert werden können. Es werden von Params hier nur die für diese Funktion relevanten Properties berücksichtigt.

g.SetScaleRef( {
  ScaleRef: 800,
  LimitScalePix: true,
  AutoScalePix: true,
  ScalePixInt: false
} );

Nicht angegebene Properties behalten ihren aktuellen Wert.

JsGraph.ScalePix(), ScalePixI()

JsGraph.ScalePix( PixelSize )
JsGraph.ScalePixI( PixelSize )

PixelSize: Number(>0)

Referenzgrösse eines Objektes in Pixel

Return: Number(>0) or Integer(>=1)

Pixelgrösse, welche der aktuellen Canvasbreite angepasst ist

Damit Pixel-Grössen wie TextSize und MarkerSize mit der Canvas-Grösse skalieren, können sie mit einer dieser Funktionen umgerechnet werden. PixelSize entspricht der Grösse, die bei einer Canvasbreite von ScaleRef verwendet werden soll. Ist die aktuelle Canvasbreite z.B. nur 1/2 ScaleRef, so geben diese Funktionen PixelSize/2 zürück.

ScalePix gibt die berechnete Pixelgrösse als reelle Zahl zurück.

ScalePixI (ScalePixI) berechnet die Pixelgrösse mit ScalePix und rundet diese danach auf die nächste ganze Zahl auf oder ab. Es wird immer ein Wert grösser oder gleich 1 zurückgegeben.

Achung: Wenn LimitScalePix = true ist, wird PixelSize nie vergrössert, sondern nur verkleinert!

JsGraph.ScalePixMin(), ScalePixMinI()

JsGraph.ScalePixMin( PixelSize, MinSize )
JsGraph.ScalePixMinI( PixelSize, MinSize )

PixelSize: Number(>0)

Referenzgrösse eines Objektes in Pixel

MinSize: Number(>0)

Minimale zurückzugebende Pixelgrösse

Return: Number(>=MinSize) or Integer(>=1,>=MinSize)

Pixelgrösse, welche der aktuellen Canvasbreite angepasst ist

Diese Funktionen sind analog den Funktionen ScalePix() und ScalePixI(). Es kann jedoch zusätzlich ein Minimalwert für die berechnete Pixelgrösse festgelegt werden.

Die Funktion ScalePixMinI() (ScalePixMinI) rundet PixelSize nach der Transformation auf ganze Zahlen nach dem Begrezen auf MinSize. Ist der Wert dann kleiner als 1, wird 1 zurückgegeben, sonst der berechnete Wert. Diese Funktion gibt nie einen Wert kleiner 1 zurück.

Achung: Wenn LimitScalePix = true ist, wird PixelSize nie vergrössert, sondern nur verkleinert!

JsGraph.ScalePixMax(), ScalePixMaxI()

JsGraph.ScalePixMax( PixelSize, MaxSize )
JsGraph.ScalePixMaxI( PixelSize, MaxSize )

PixelSize: Number(>0)

Referenzgrösse eines Objektes in Pixel

MaxSize: Number(>0)

Maximale zurückzugebende Pixelgrösse

Return: Number(>0,<=MaxSize) or Integer(>=1,<=MaxSize)

Pixelgrösse, welche der aktuellen Canvasbreite angepasst ist

Diese Funktionen sind analog den Funktionen ScalePix() und ScalePixI(). Es kann jedoch zusätzlich ein Maximalwert für die berechnete Pixelgrösse festgelegt werden.

Die Funktion ScalePixMaxI() (ScalePixMaxI) rundet PixelSize nach der Transformation auf ganze Zahlen nach dem Begrezen auf MaxSize. Ist der Wert kleiner als 1, wird 1 zurückgegeben. Diese Funktion gibt nie einen Wert kleiner 1 zurück.

Achung: Wenn LimitScalePix = true ist, wird PixelSize nie vergrössert, sondern nur verkleinert!

JsGraph.ScalePixMinMax(), ScalePixMinMaxI()

JsGraph.ScalePixMinMax( PixelSize, MinSize, MaxSize )
JsGraph.ScalePixMinMaxI( PixelSize, MinSize, MaxSize )

PixelSize: Number(>0)

Referenzgrösse eines Objektes in Pixel

MinSize: Number(>0)

Minimale zurückzugebende Pixelgrösse

MaxSize: Number(>0)

Maximale zurückzugebende Pixelgrösse

Return: Number(>=MinSize,<=MaxSize) or Integer(>=1,>=MinSize,<=MaxSize)

Pixelgrösse, welche der aktuellen Canvasbreite angepasst ist

Diese Funktionen sind analog den Funktionen ScalePix() und ScalePixI(). Es kann jedoch zusätzlich ein Minimalwert und ein Maximalwert für die berechnete Pixelgrösse festgelegt werden.

Die Funktion ScalePixMinMaxI() (ScalePixMinMaxI) rundet PixelSize nach der Transformation auf ganze Zahlen nach dem Begrezen auf MinSize und MaxSize. Ist der Wert kleiner als 1, wird 1 zurückgegeben. Diese Funktion gibt nie einen Wert kleiner 1 zurück.

Achung: Wenn LimitScalePix = true ist, wird PixelSize nie vergrössert, sondern nur verkleinert!

JsGraph.MinSize(), MaxSize(), MinMaxSize()

JsGraph.MinSize( Size, LowerLimit )
JsGraph.MaxSize( Size, UpperLimit )
JsGraph.MinMaxSize( Size, LowerLimit, UpperLimit )

Size: Number

Vorgabewert

LowerLimit: Number(<=UpperLimit)

Minimaler Wert

UpperLimit: number(>=LowerLimit)

Maximaler Wert

return: Number

Size innerhalb der Grenzen

Mit diesen Funktionen kann man den Wert Size nach unten und/oder oben begrenzen.

JsGraph.ScaleToTic()

JsGraph.ScaleToTic( Value, TicSpan )

Value: Number

Vorgabewert

TicSpan: Number(>0)

Abstand der Tics

Return: Number

Value plus Padding, sodass Return ein Vielfaches von TicSpan ist

Manchmal kann die Grösse eines Windows erst durch die Berechnung einer zu zeichnenden Funktion ermittelt werden. Damit die Window-Grösse so festgelegt wird, dass sie bei einem Tic endet und die Funktion enthält, kann die entsprechende Grösse mit Hilfe dieser Funktion berechnet werden.

var TicSpan = 5;
var poly = ComputeFunction( windowXmin, windowXmax );
var yMin = GetMinimum( poly );
var yMax = GetMaximum( poly );
var windowYmin = jsg.ScaleToTic( yMin, TicSpan );
var windowYmax = jsg.ScaleToTic( yMax, TicSpan );
jsg.SetWindow( windowXmin, windowYmin, windowXmax, windowYmax );

JsGraph.AngleToRad()

JsGraph.AngleToRad( angle )

angle: Number

Winkel in Grad oder Radian

Return: Number

Winkel in Radian

Wenn AngleMeasure = 'grad' ist, wird angle als Winkel in Grad interpretiert und in Radian umgewandelt. Wenn AngleMeasure = 'rad' ist, wird angle zurückgegeben.

JsGraph.DegToRad(), RadToDeg()

JsGraph.DegToRad( angle )
JsGraph.RadToDeg( angle )

angle: Number

Winkel in Grad oder Radian

Return: Number

Umgerechneter Winkel

Mit der Funtkion DegToRad kann ein Winel von Grad in Radian umgerechnet werden. Mit der Funktion RadToDeg kann ein Winkel von Radian in Grad umgerechnet werden.

JsGraph.ScaleWinX(), ScaleWinY()

JsGraph.ScaleWinX( )
JsGraph.ScaleWinY( )

Return: Number(>0)

Skalierungsfaktor von Windows- in Viewport-/Canvas-Koordinaten.

ScaleWinX und ScaleWinY geben den Skalierungsfaktor der Transformation von Windows- in Viewport-/Canvas-Koordinaten zurück.

Ähnliche Funktionen mit einfacherer Anwenung sind WinToPixX(), WinToPixY(), PixToWinX() und PixToWinY().

Anwendung:

pixelX = spanWinX * jsg.ScaleWinX();
pixelY = spanWinY * jsg.ScaleWinY();

spanWinX = pixelX / jsg.ScaleWinX();
spanWinY = pixelY / jsg.ScaleWinY();

Diese Funktionen sind praktisch, wenn man wissen will, wie viele Pixel lang eine bestimmte Einheit ist oder wenn man wissen will, wie gross in Weltkoordinaten man etwas zeichnen muss, damit es eine bestimmte Anzahl Pixel gross auf dem Viewport/Canvas wird.

Hinweis: Viewport- und Canvas-Koordinaten haben dieselbe Skalierung (Pixel). Sie unterscheiden sich nur im Offset des Viewports. Daher braucht es nur für jede Achse je eine Skalierungs-Funktion zum Umrechnen der Skalierung von Window- in Viewport- oder Canvas-Koordinaten.

Achtung: Wenn bei SetWindow() Xmin > Xmax oder Ymin > Ymax angegeben wird, handelt es sich um eine Spiegel-Transformation. Der Skalierungsfaktor ist jedoch immer positiv.

JsGraph.WinToPixX(), WinToPixY()

JsGraph.WinToPixX( winX, scalePix )
JsGraph.WinToPixY( winY, scalePix )

winX, winY: Number

Länge in Window-Koordinaten

scalePix: Boolean; Optional; Default = AutoScalePix

wenn true wird die Funktion ScalePix() zusätzlich angewandt.

Return: Number(>=0)

länge in pixel

Diese Funktionen sind praktisch, wenn man wissen will, wie viele Pixel lang eine bestimmte Länge in Window-Koordinaten. Vergleiche auch mit den Funktionen ScaleWinX() und ScaleWinY().

Hinweis: Viewport- und Canvas-Koordinaten haben dieselbe Skalierung (Pixel). Sie unterscheiden sich nur im Offset des Viewports. Daher braucht es nur für jede Achse je eine Funktion zum Umrechnen der Skalierung von Window- in Pixel-Koordinaten.

Achtung: Wenn bei SetWindow() Xmin > Xmax oder Ymin > Ymax angegeben wird, handelt es sich um eine Spiegel-Transformation. Der Pixel-Wert ist jedoch immer positiv.

JsGraph.PixToWinX(), PixToWinY()

JsGraph.PixToWinX( pixX, scalePix )
JsGraph.PixToWinY( pixY, scalePix )

pixX, pixY: Number

Länge in Pixel-Koordinaten

scalePix: Boolean; Optional; Default = AutoScalePix

wenn true wird die Funktion ScalePix() zusätzlich angewandt.

Return: Number(>=0)

länge in Window-Koordinaten

Diese Funktionen sind praktisch, wenn man wissen will, wie viel man ein Objekt in Window-Koordinaten verschieben muss dass es auf dem Bildschirm pix Pixel verschoben ist. Vergleiche auch mit den Funktionen ScaleWinX() und ScaleWinY().

Hinweis: Viewport- und Canvas-Koordinaten haben dieselbe Skalierung (Pixel). Sie unterscheiden sich nur im Offset des Viewports. Daher braucht es nur für jede Achse je eine Funktion zum Umrechnen der Skalierung von Pixel- in Window-Koordinaten.

Achtung: Wenn bei SetWindow() Xmin > Xmax oder Ymin > Ymax angegeben wird, handelt es sich um eine Spiegel-Transformation. Der Window-Wert ist jedoch immer positiv.

JsGraph.TransWinCnvsX(), TransWinCnvsY()

JsGraph.TransWinCnvsX( winX )
JsGraph.TransWinCnvsY( winY )

winX, winY: Number

Werte in Weltkoordinaten.

Return: Number

Werte in Canvas-Koordinaten (Pixel).

TransWinCnvsX und TransWinCnvsY transformieren von Windows- in Canvas-Koordinaten. Diese Funktionen werden intern von den Zeichenfunktionen verwendet.

cnvsX = jsg.TransWinCnvsX( winX );
cnvsY = jsg.TransWinCnvsY( winY );

Hinweis: Dank Anti-Aliasing beim Zeichnen können auch Bruchwerte als Canvas-Koordinaten verwendet werden (siehe auch Abbildung).

JsGraph.TransCnvsWinX(), TransCnvsWinY()

JsGraph.TransCnvsWinX( cnvsX )
JsGraph.TransCnvsWinY( cnvsY )

cnvsX, cnvsY: Number

Werte in Canvas-Koordinaten (Pixel).

Return: Number

Werte in Windows-Koordinaten.

TransCnvsWinX und TransCnvsWinY transformieren von Canvas- in Window-Koordinaten. Diese Funktionen sind die Umkehrung der obigen beiden Funktionen.

winX = jsg.TransCnvsWinX( cnvsX );
winY = jsg.TransCnvsWinY( cnvsY );

Hinweis: Dank Anti-Aliasing beim Zeichnen können auch Bruchwerte als Canvas-Koordinaten verwendet werden (siehe auch Abbildung).

JsGraph.TransVpCnvsX(), TransVpCnvsY()

JsGraph.TransVpCnvsX( vpX )
JsGraph.TransVpCnvsY( vpY )

vpX, vpY: Number

Werte in Viewport-Koordinaten.

Return: Number

Werte in Canvas-Koordinaten (Pixel).

TransVpCnvsX und TransVpCnvsY transformieren von Viewport- in Canvas-Koordinaten. Diese Funktionen werden intern von den Zeichenfunktionen verwendet, welche Werte in Viewport-Koordinaten verwenden.

cnvsX = jsg.TransVpCnvsX( vpX );
cnvsY = jsg.TransVpCnvsY( vpY );

Hinweis: Dank Anti-Aliasing beim Zeichnen können auch Bruchwerte als Viewport/Canvas-Koordinaten verwendet werden (siehe auch Abbildung).

JsGraph.TransCnvsVpX(), TransCnvsVpY()

JsGraph.TransCnvsVpX( cnvsX )
JsGraph.TransCnvsVpY( cnvsY )

cnvsX, cnvsY: Number

Werte in Canvas-Koordinaten (Pixel).

Return: Number

Werte in Viewport-Koordinaten.

TransCnvsVpX und TransCnvsVpY transformieren von Canvas- in Viewport-Koordinaten. Diese Funktionen sind die Umkehrung der obigen beiden Funktionen.

vpX = jsg.TransCnvsVpX( cnvsX );
vpY = jsg.TransCnvsVpY( cnvsY );

Hinweis: Dank Anti-Aliasing beim Zeichnen können auch Bruchwerte als Viewport/Canvas-Koordinaten verwendet werden (siehe auch Abbildung).

JsGraph.TransWinVpX(), TransWinVpY()

JsGraph.TransWinVpX( winX )
JsGraph.TransWinVpY( winY )

winX, winY: Number

Werte in Weltkoordinaten.

Return: Number

Werte in Viewport-Koordinaten (Pixel).

TransWinVpX und TransWinVpY transformieren von Windows- in Viewport-Koordinaten. Diese Funktionen werden intern von einigen Zeichenfunktionen verwendet.

vpX = jsg.TransWinVpX( winX );
vpY = jsg.TransWinVpY( winY );

Hinweis: Dank Anti-Aliasing beim Zeichnen können auch Bruchwerte als Viewport-Koordinaten verwendet werden (siehe auch Abbildung).

JsGraph.TransVpWinX(), TransVpWinY()

JsGraph.TransVpWinX( vpX )
JsGraph.TransVpWinY( vpY )

vpX, vpY: Number

Werte in Viewport-Koordinaten.

Return: Number

Werte in Window-Koordinaten.

TransVpWinX und TransVpWinY transformieren von Viewport- in Window-Koordinaten. Diese Funktionen sind die Umkehrung der obigen beiden Funktionen.

winX = jsg.TransVpWinX( vpX );
winY = jsg.TransVpWinY( vpY );

Hinweis: Dank Anti-Aliasing beim Zeichnen können auch Bruchwerte als Viewport-Koordinaten verwendet werden (siehe auch Abbildung).

JsGraph.TransXY()

JsGraph.TransXY( x, y )

x, y: Number

Koordinaten eines Punktes im aktuellen Koordinatensystem

Return this.CurrTrans: JsgTrans

Objekt enthält die Korrdinaten im Canvas-Koordinatensytem in den Properties x und y

Transformiert einen Punkt (x,y) vom aktuellen Koordinatensystem in Canvas-Koordinaten, wobei auch die Objekt-Transformation angewandt wird. Die resultierenden Koordinaten sind im zurückgegebenen Objekt this.CurrTrans in den Properties x und y gespeichert.

var pntCanvas = jsg.TransXY( 123, 456 );
var xCnvs = pntCanvas.x;
var yCnvs = pntCanvas.y;

JsGraph.TransPoly()

JsGraph.TransPoly( poly )

poly: JsgPolygon

Koordinaten eines Polygons im aktuellen Koordinatensystem

Transformiert die Koordinaten des Polygons poly vom aktuellen Koordinatensystem in Canvas-Koordinaten, wobei auch die Objekt-Transformation angewandt wird. Die Koordinaten in poly werden mit den neuen Werten überschrieben.

JsGraph.ObjTransXY()

JsGraph.ObjTransXY( x, y )

x, y: Number

Koordinaten eines Punktes

Return this.ObjTrans: JsgTrans2D

Objekt enthält die neuen Korrdinaten in den Properties x und y

Transformiert einen Punkt (x,y) über die aktuelle Objekt-Transformation. Die resultierenden Koordinaten sind im zurückgegebenen Objekt this.ObjTrans in den Properties x und y gespeichert.

var newPoint = jsg.ObjTransXY( 123, 456 );
var xNew = newPoint.x;
var yNew = newPoint.y;

JsGraph.ObjTransPoly()

JsGraph.ObjTransPoly( poly )

poly: JsgPolygon

Koordinaten eines Polygons

Transformiert die Koordinaten des Polygons poly über die aktuelle Objekt-Transformation. Die Koordinaten in poly werden mit den neuen Werten überschrieben.

Im folgenden Beispiel wird ein Spline in ein Polygon umgerechnet, welches die dem Spline entsprechenden Bezier-Segmente enthält. Die Bezier-Punkte werden danach mit der aktuellen Objekt-Transformation transformiert.

// spline: JsgPolygon
var spline = CreateSpline( ... );

// SplineCurve() gibt das jsg.WorkPoly zurück, welches die berechneten Bezier-Segmente enthält 
// mode = 0 -> Spline wird nicht gezeichnet, 
// es werden nur die nicht transformierten Bezier-Segmente berechnet 
var workPoly = jsg.SplineCurve( spline, tension, 0 );

// Bezier-Polygon kopieren und transformieren
var bezierSegments = JsgPolygon.Copy( workPoly );
jsg.ObjTransPoly( bezierSegments );

Das Polygon bezierSegments enthält die Bezier Stütz- und Kontrollpunkte in folgender Reihenfolge:

poly: [ P1, C1b, C2a, P2, C2b, C3a, P3, C3b, C4a, P4, ... ]

Die Punkte P<i> sind die Stützpunkte der Bezier-Segmente, die Punkte C<i>a und C<i>b sind die zwischen zwei Stützpunkten liegenden Kotrollpunkte. Jeder Stützpunkt P<i>, ausser dem ersten und letzten Punkt des Polygons, hat zwei Kontrollpunkte C<i>a und C<i>b.

JsGraph.IsPointInsideRect()

JsGraph.IsPointInsideRect( x, y, xmin, xmax, ymin, ymax )

x, y: Number

Punktkoordinaten

xmin, xmax, ymin, ymax: Number

Rechteckbereich

Return: Boolean

Gibt True zurück, wenn der Punkt (x,y) vollständig innerhalb des Bereiches xmin bis ymax oder auf seiner Kante liegt.

JsGraph.IsPolygonInsideRect()

JsGraph.IsPointInsideRect( xArray, yArray, size, xmin, xmax, ymin, ymax )
JsGraph.IsPointInsideRect( poly, xmin, xmax, ymin, ymax )

xArray, yArray: array of Number

Koordinaten des Polygons

size: Integer(>0)

Anzahl Polygon-Punkte

poly: JsgPolygon

xmin, xmax, ymin, ymax: Number

Rechteckbereich

Return: Boolean

Gibt True zurück, wenn alle Punkte des Polygons vollständig innerhalb des Bereiches xmin bis ymax oder auf seiner Kante liegen.