AGI STK VGT 11 Send comments on this topic.
IAgCrdnProvider Interface





Description

Allows accessing existing Vector Geometry Tool components.

Object Model



















Public Methods

Public Method Import Imports Analysis Workbench components from a file.
Public Method Supports Tests whether the specified VGT feature is supported.

Public Properties

Public Property Angles Returns a group of angles.
Public Property Axes Returns a group of axes.
Public Property CalcScalars Returns a group of calc scalars.
Public Property Conditions Returns a group of condition objects.
Public Property ConditionSets Returns a group of condition set objects.
Public Property EventArrays Returns a group of event arrays.
Public Property EventIntervalCollections Returns a group of event interval collections.
Public Property EventIntervalLists Returns a group of event interval lists.
Public Property EventIntervals Returns a group of event intervals.
Public Property Events Returns a group of events.
Public Property ParameterSets Access, add new or remove existing parameter set components.
Public Property Planes Returns a group of planes.
Public Property Points Returns a group of points.
Public Property Systems Returns a group of systems.
Public Property Vectors Returns a group of vectors.
Public Property WellKnownAxes Returns well-known axes.
Public Property WellKnownSystems Returns well-known systems.

Example

Enumerate the existing vectors.
[C#] Copy Code
// Enumerate the existing vectors using specified CrdnProvider. 
foreach (IAgCrdnVector vector in provider.Vectors) 
{ 
    // All vectors implement IAgCrdn interface which provides 
    // information about the vector instance and its type. 
    IAgCrdn crdn = vector as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, vector.Type); 
} 
 
Enumerate the existing points.
[C#] Copy Code
// Enumerate the existing points using specified CrdnProvider. 
foreach (IAgCrdnPoint point in provider.Points) 
{ 
    // All points implement IAgCrdn interface which provides 
    // information about the point instance and its type. 
    IAgCrdn crdn = point as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, point.Type); 
} 
 
Enumerate the existing angles.
[C#] Copy Code
// Enumerate the existing angles using specified CrdnProvider. 
foreach (IAgCrdnAngle angle in provider.Angles) 
{ 
    // All angles implement IAgCrdn interface which provides 
    // information about the angle instance and its type. 
    IAgCrdn crdn = angle as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, angle.Type); 
} 
 
Enumerate the existing axes.
[C#] Copy Code
// Enumerate the existing Axes using specified CrdnProvider. 
foreach (IAgCrdnAxes axes in provider.Axes) 
{ 
    // All axes implement IAgCrdn interface which provides 
    // information about the axes instance and its type. 
    IAgCrdn crdn = axes as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, axes.Type); 
} 
 
Enumerate the existing planes.
[C#] Copy Code
// Enumerate the existing Planes using specified CrdnProvider. 
foreach (IAgCrdnPlane plane in provider.Planes) 
{ 
    // All planes implement IAgCrdn interface which provides 
    // information about the plane instance and its type. 
    IAgCrdn crdn = plane as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, plane.Type); 
} 
 
Enumerate the existing systems.
[C#] Copy Code
// Enumerate the existing Systems using specified CrdnProvider. 
foreach (IAgCrdnSystem system in provider.Systems) 
{ 
    // All systems implement IAgCrdn interface which provides 
    // information about the system instance and its type. 
    IAgCrdn crdn = system as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, system.Type); 
} 
 
Enumerate the existing parameter sets.
[C#] Copy Code
// Enumerate the existing ParameterSets using specified CrdnProvider. 
foreach (IAgCrdnParameterSet parameterSet in provider.ParameterSets) 
{ 
    // All parameter sets implement IAgCrdn interface which provides 
    // information about the parameter set instance and its type. 
    IAgCrdn crdn = parameterSet as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, parameterSet.Type); 
} 
 
Enumerate the existing calc scalars.
[C#] Copy Code
// Enumerate the existing CalcScalars using specified CrdnProvider. 
foreach (IAgCrdnCalcScalar calcScalar in provider.CalcScalars) 
{ 
    // All calc scalars implement IAgCrdn interface which provides 
    // information about the calc scalar instance and its type. 
    IAgCrdn crdn = calcScalar as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, calcScalar.Type); 
} 
 
Enumerate the existing conditions.
[C#] Copy Code
// Enumerate the existing Conditions using specified CrdnProvider. 
foreach (IAgCrdnCondition condition in provider.Conditions) 
{ 
    // All conditions implement IAgCrdn interface which provides 
    // information about the condition instance and its type. 
    IAgCrdn crdn = condition as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, condition.Type); 
} 
 
Enumerate the existing events.
[C#] Copy Code
// Enumerate the existing Events using specified CrdnProvider. 
foreach (IAgCrdnEvent @event in provider.Events) 
{ 
    // All events implement IAgCrdn interface which provides 
    // information about the event instance and its type. 
    IAgCrdn crdn = @event as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, @event.Type); 
} 
 
Enumerate the existing event arrays.
[C#] Copy Code
// Enumerate the existing EventArrays using specified CrdnProvider. 
foreach (IAgCrdnEventArray eventArray in provider.EventArrays) 
{ 
    // All event arrays implement IAgCrdn interface which provides 
    // information about the event array instance and its type. 
    IAgCrdn crdn = eventArray as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventArray.Type); 
} 
 
Enumerate the existing event intervals.
[C#] Copy Code
// Enumerate the existing EventIntervals using specified CrdnProvider. 
foreach (IAgCrdnEventInterval eventInterval in provider.EventIntervals) 
{ 
    // All event intervals implement IAgCrdn interface which provides 
    // information about the event interval instance and its type. 
    IAgCrdn crdn = eventInterval as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventInterval.Type); 
} 
 
Enumerate the existing event interval collections.
[C#] Copy Code
// Enumerate the existing EventIntervalCollections using specified CrdnProvider. 
foreach (IAgCrdnEventIntervalCollection eventIntervalCollection in provider.EventIntervalCollections) 
{ 
    // All event interval collections implement IAgCrdn interface which provides 
    // information about the event interval collection instance and its type. 
    IAgCrdn crdn = eventIntervalCollection as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventIntervalCollection.Type); 
} 
 
Enumerate the existing event interval lists.
[C#] Copy Code
// Enumerate the existing EventIntervalLists using specified CrdnProvider. 
foreach (IAgCrdnEventIntervalList eventIntervalList in provider.EventIntervalLists) 
{ 
    // All event interval lists implement IAgCrdn interface which provides 
    // information about the event interval list instance and its type. 
    IAgCrdn crdn = eventIntervalList as IAgCrdn; 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventIntervalList.Type); 
} 
 
Iterate through the existing vectors.
[C#] Copy Code
// Iterate through the the group of existing vectors associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.Vectors.Count; i++) 
{ 
    IAgCrdnVector vector = provider.Vectors[i]; 
    // All vectors implement IAgCrdn interface which provides 
    // information about the vector instance and its type. 
    IAgCrdn crdn = vector as IAgCrdn; 
    // Print the vector name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, vector.Type); 
} 
 
Iterate through the existing points.
[C#] Copy Code
// Iterate through the the group of existing points associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.Points.Count; i++) 
{ 
    IAgCrdnPoint point = provider.Points[i]; 
    // All points implement IAgCrdn interface which provides 
    // information about the point instance and its type. 
    IAgCrdn crdn = provider.Points[i] as IAgCrdn; 
    // Print the point name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, point.Type); 
} 
 
Iterate through existing angles.
[C#] Copy Code
// Iterate through the the group of existing angles associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.Angles.Count; i++) 
{ 
    IAgCrdnAngle angle = provider.Angles[i]; 
    // All angles implement IAgCrdn interface which provides 
    // information about the angle instance and its type. 
    IAgCrdn crdn = provider.Angles[i] as IAgCrdn; 
    // Print the angle name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, angle.Type); 
} 
 
Iterate through existing axes.
[C#] Copy Code
// Iterate through the the group of existing angles associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.Axes.Count; i++) 
{ 
    IAgCrdnAxes axes = provider.Axes[i]; 
    // All axes implement IAgCrdn interface which provides 
    // information about the axes instance and its type. 
    IAgCrdn crdn = provider.Axes[i] as IAgCrdn; 
    // Print the axes name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, axes.Type); 
} 
 
Iterate through existing planes.
[C#] Copy Code
// Iterate through the the group of existing planes associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.Planes.Count; i++) 
{ 
    IAgCrdnPlane plane = provider.Planes[i]; 
    // All planes implement IAgCrdn interface which provides 
    // information about the plane's instance and its type. 
    IAgCrdn crdn = provider.Planes[i] as IAgCrdn; 
    // Print the plane's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, plane.Type); 
} 
 
Iterate through existing systems (coordinate reference frames).
[C#] Copy Code
// Iterate through the the group of existing systems associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.Systems.Count; i++) 
{ 
    IAgCrdnSystem crdnSystem = provider.Systems[i]; 
    // All coordinate reference frames implement IAgCrdn interface which provides 
    // information about the reference frame's instance and its type. 
    IAgCrdn crdn = provider.Systems[i] as IAgCrdn; 
    // Print the reference frame's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, crdnSystem.Type); 
} 
 
Iterate through existing parameter sets.
[C#] Copy Code
// Iterate through the the group of existing parameter sets associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.ParameterSets.Count; i++) 
{ 
    IAgCrdnParameterSet parameterSet = provider.ParameterSets[i]; 
    // All parameter sets implement IAgCrdn interface which provides 
    // information about the parameter set's instance and its type. 
    IAgCrdn crdn = provider.ParameterSets[i] as IAgCrdn; 
    // Print the parameter set's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, parameterSet.Type); 
} 
 
Iterate through existing calc scalars.
[C#] Copy Code
// Iterate through the the group of existing calc scalars associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.CalcScalars.Count; i++) 
{ 
    IAgCrdnCalcScalar calcScalar = provider.CalcScalars[i]; 
    // All calc scalars implement IAgCrdn interface which provides 
    // information about the calc scalar's instance and its type. 
    IAgCrdn crdn = provider.CalcScalars[i] as IAgCrdn; 
    // Print the calc scalar's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, calcScalar.Type); 
} 
 
Iterate through existing conditions.
[C#] Copy Code
// Iterate through the the group of existing conditions associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.Conditions.Count; i++) 
{ 
    IAgCrdnCondition condition = provider.Conditions[i]; 
    // All conditions implement IAgCrdn interface which provides 
    // information about the condition's instance and its type. 
    IAgCrdn crdn = provider.Conditions[i] as IAgCrdn; 
    // Print the condition's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, condition.Type); 
} 
 
Iterate through existing events.
[C#] Copy Code
// Iterate through the the group of existing events associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.Events.Count; i++) 
{ 
    IAgCrdnEvent @event = provider.Events[i]; 
    // All events implement IAgCrdn interface which provides 
    // information about the event's instance and its type. 
    IAgCrdn crdn = provider.Events[i] as IAgCrdn; 
    // Print the event's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, @event.Type); 
} 
 
Iterate through existing event arrays.
[C#] Copy Code
// Iterate through the the group of existing event arrays associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.EventArrays.Count; i++) 
{ 
    IAgCrdnEventArray eventArray = provider.EventArrays[i]; 
    // All event arrays implement IAgCrdn interface which provides 
    // information about the event array's instance and its type. 
    IAgCrdn crdn = provider.EventArrays[i] as IAgCrdn; 
    // Print the event array's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventArray.Type); 
} 
 
Iterate through existing event intervals.
[C#] Copy Code
// Iterate through the the group of existing event intervals associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.EventIntervals.Count; i++) 
{ 
    IAgCrdnEventInterval eventInterval = provider.EventIntervals[i]; 
    // All event intervals implement IAgCrdn interface which provides 
    // information about the event interval's instance and its type. 
    IAgCrdn crdn = provider.EventIntervals[i] as IAgCrdn; 
    // Print the event interval's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventInterval.Type); 
} 
 
Iterate through existing event interval collections.
[C#] Copy Code
// Iterate through the the group of existing event interval collections associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.EventIntervalCollections.Count; i++) 
{ 
    IAgCrdnEventIntervalCollection eventIntervalCollection = provider.EventIntervalCollections[i]; 
    // All event interval collections implement IAgCrdn interface which provides 
    // information about the event interval collection's instance and its type. 
    IAgCrdn crdn = provider.EventIntervalCollections[i] as IAgCrdn; 
    // Print the event interval collection's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventIntervalCollection.Type); 
} 
 
Iterate through existing event interval lists.
[C#] Copy Code
// Iterate through the the group of existing event interval lists associated 
// with the specified CrdnProvider. 
for (int i = 0; i < provider.EventIntervalLists.Count; i++) 
{ 
    IAgCrdnEventIntervalList eventIntervalList = provider.EventIntervalLists[i]; 
    // All event interval lists implement IAgCrdn interface which provides 
    // information about the event interval list's instance and its type. 
    IAgCrdn crdn = provider.EventIntervalLists[i] as IAgCrdn; 
    // Print the event interval list's name and type to the standard output. 
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventIntervalList.Type); 
} 
 
Enumerate the existing vectors.
[Visual Basic .NET] Copy Code
' Enumerate the existing vectors using specified CrdnProvider.
For Each vector As IAgCrdnVector In provider.Vectors
    ' All vectors implement IAgCrdn interface which provides
    ' information about the vector instance and its type.
    Dim crdn As IAgCrdn = TryCast(vector, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, vector.Type)
Next
Enumerate the existing points.
[Visual Basic .NET] Copy Code
' Enumerate the existing points using specified CrdnProvider.
For Each point As IAgCrdnPoint In provider.Points
    ' All points implement IAgCrdn interface which provides
    ' information about the point instance and its type.
    Dim crdn As IAgCrdn = TryCast(point, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, point.Type)
Next
Enumerate the existing angles.
[Visual Basic .NET] Copy Code
' Enumerate the existing angles using specified CrdnProvider.
For Each angle As IAgCrdnAngle In provider.Angles
    ' All angles implement IAgCrdn interface which provides
    ' information about the angle instance and its type.
    Dim crdn As IAgCrdn = TryCast(angle, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, angle.Type)
Next
Enumerate the existing axes.
[Visual Basic .NET] Copy Code
' Enumerate the existing Axes using specified CrdnProvider.
For Each axes As IAgCrdnAxes In provider.Axes
    ' All axes implement IAgCrdn interface which provides
    ' information about the axes instance and its type.
    Dim crdn As IAgCrdn = TryCast(axes, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, axes.Type)
Next
Enumerate the existing planes.
[Visual Basic .NET] Copy Code
' Enumerate the existing Planes using specified CrdnProvider.
For Each plane As IAgCrdnPlane In provider.Planes
    ' All planes implement IAgCrdn interface which provides
    ' information about the plane instance and its type.
    Dim crdn As IAgCrdn = TryCast(plane, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, plane.Type)
Next
Enumerate the existing systems.
[Visual Basic .NET] Copy Code
' Enumerate the existing Systems using specified CrdnProvider.
For Each system As IAgCrdnSystem In provider.Systems
    ' All systems implement IAgCrdn interface which provides
    ' information about the system instance and its type.
    Dim crdn As IAgCrdn = TryCast(system, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, system.Type)
Next
Enumerate the existing parameter sets.
[Visual Basic .NET] Copy Code
' Enumerate the existing ParameterSets using specified CrdnProvider.
For Each parameterSet As IAgCrdnParameterSet In provider.ParameterSets
    ' All parameter sets implement IAgCrdn interface which provides
    ' information about the parameter set instance and its type.
    Dim crdn As IAgCrdn = TryCast(parameterSet, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, parameterSet.Type)
Next
Enumerate the existing calc scalars.
[Visual Basic .NET] Copy Code
' Enumerate the existing CalcScalars using specified CrdnProvider.
For Each calcScalar As IAgCrdnCalcScalar In provider.CalcScalars
    ' All calc scalars implement IAgCrdn interface which provides
    ' information about the calc scalar instance and its type.
    Dim crdn As IAgCrdn = TryCast(calcScalar, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, calcScalar.Type)
Next
Enumerate the existing conditions.
[Visual Basic .NET] Copy Code
' Enumerate the existing Conditions using specified CrdnProvider.
For Each condition As IAgCrdnCondition In provider.Conditions
    ' All conditions implement IAgCrdn interface which provides
    ' information about the condition instance and its type.
    Dim crdn As IAgCrdn = TryCast(condition, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, condition.Type)
Next
Enumerate the existing events.
[Visual Basic .NET] Copy Code
' Enumerate the existing Events using specified CrdnProvider.
For Each [event] As IAgCrdnEvent In provider.Events
    ' All events implement IAgCrdn interface which provides
    ' information about the event instance and its type.
    Dim crdn As IAgCrdn = TryCast([event], IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, [event].Type)
Next
Enumerate the existing event arrays.
[Visual Basic .NET] Copy Code
' Enumerate the existing EventArrays using specified CrdnProvider.
For Each eventArray As IAgCrdnEventArray In provider.EventArrays
    ' All event arrays implement IAgCrdn interface which provides
    ' information about the event array instance and its type.
    Dim crdn As IAgCrdn = TryCast(eventArray, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventArray.Type)
Next
Enumerate the existing event intervals.
[Visual Basic .NET] Copy Code
' Enumerate the existing EventIntervals using specified CrdnProvider.
For Each eventInterval As IAgCrdnEventInterval In provider.EventIntervals
    ' All event intervals implement IAgCrdn interface which provides
    ' information about the event interval instance and its type.
    Dim crdn As IAgCrdn = TryCast(eventInterval, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventInterval.Type)
Next
Enumerate the existing event interval collections.
[Visual Basic .NET] Copy Code
' Enumerate the existing EventIntervalCollections using specified CrdnProvider.
For Each eventIntervalCollection As IAgCrdnEventIntervalCollection In provider.EventIntervalCollections
    ' All event interval collections implement IAgCrdn interface which provides
    ' information about the event interval collection instance and its type.
    Dim crdn As IAgCrdn = TryCast(eventIntervalCollection, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventIntervalCollection.Type)
Next
Enumerate the existing event interval lists.
[Visual Basic .NET] Copy Code
' Enumerate the existing EventIntervalLists using specified CrdnProvider.
For Each eventIntervalList As IAgCrdnEventIntervalList In provider.EventIntervalLists
    ' All event interval lists implement IAgCrdn interface which provides
    ' information about the event interval list instance and its type.
    Dim crdn As IAgCrdn = TryCast(eventIntervalList, IAgCrdn)
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventIntervalList.Type)
Next
Iterate through the existing vectors.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing vectors associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim vector As IAgCrdnVector = provider.Vectors(i)
    ' All vectors implement IAgCrdn interface which provides
    ' information about the vector instance and its type.
    Dim crdn As IAgCrdn = TryCast(vector, IAgCrdn)
    ' Print the vector name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, vector.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through the existing points.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing points associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim point As IAgCrdnPoint = provider.Points(i)
    ' All points implement IAgCrdn interface which provides
    ' information about the point instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.Points(i), IAgCrdn)
    ' Print the point name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, point.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing angles.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing angles associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim angle As IAgCrdnAngle = provider.Angles(i)
    ' All angles implement IAgCrdn interface which provides
    ' information about the angle instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.Angles(i), IAgCrdn)
    ' Print the angle name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, angle.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing axes.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing angles associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim axes As IAgCrdnAxes = provider.Axes(i)
    ' All axes implement IAgCrdn interface which provides
    ' information about the axes instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.Axes(i), IAgCrdn)
    ' Print the axes name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, axes.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing planes.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing planes associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim plane As IAgCrdnPlane = provider.Planes(i)
    ' All planes implement IAgCrdn interface which provides
    ' information about the plane's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.Planes(i), IAgCrdn)
    ' Print the plane's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, plane.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing systems (coordinate reference frames).
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing systems associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim crdnSystem As IAgCrdnSystem = provider.Systems(i)
    ' All coordinate reference frames implement IAgCrdn interface which provides
    ' information about the reference frame's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.Systems(i), IAgCrdn)
    ' Print the reference frame's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, crdnSystem.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing parameter sets.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing parameter sets associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim parameterSet As IAgCrdnParameterSet = provider.ParameterSets(i)
    ' All parameter sets implement IAgCrdn interface which provides
    ' information about the parameter set's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.ParameterSets(i), IAgCrdn)
    ' Print the parameter set's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, parameterSet.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing calc scalars.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing calc scalars associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim calcScalar As IAgCrdnCalcScalar = provider.CalcScalars(i)
    ' All calc scalars implement IAgCrdn interface which provides
    ' information about the calc scalar's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.CalcScalars(i), IAgCrdn)
    ' Print the calc scalar's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, calcScalar.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing conditions.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing conditions associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim condition As IAgCrdnCondition = provider.Conditions(i)
    ' All conditions implement IAgCrdn interface which provides
    ' information about the condition's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.Conditions(i), IAgCrdn)
    ' Print the condition's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, condition.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing events.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing events associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim [event] As IAgCrdnEvent = provider.Events(i)
    ' All events implement IAgCrdn interface which provides
    ' information about the event's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.Events(i), IAgCrdn)
    ' Print the event's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, [event].Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing event arrays.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing event arrays associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim eventArray As IAgCrdnEventArray = provider.EventArrays(i)
    ' All event arrays implement IAgCrdn interface which provides
    ' information about the event array's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.EventArrays(i), IAgCrdn)
    ' Print the event array's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventArray.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing event intervals.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing event intervals associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim eventInterval As IAgCrdnEventInterval = provider.EventIntervals(i)
    ' All event intervals implement IAgCrdn interface which provides
    ' information about the event interval's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.EventIntervals(i), IAgCrdn)
    ' Print the event interval's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventInterval.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing event interval collections.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing event interval collections associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim eventIntervalCollection As IAgCrdnEventIntervalCollection = provider.EventIntervalCollections(i)
    ' All event interval collections implement IAgCrdn interface which provides
    ' information about the event interval collection's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.EventIntervalCollections(i), IAgCrdn)
    ' Print the event interval collection's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventIntervalCollection.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Iterate through existing event interval lists.
[Visual Basic .NET] Copy Code
' Iterate through the the group of existing event interval lists associated
' with the specified CrdnProvider.
Dim i As Integer = 0
While i <>
    Dim eventIntervalList As IAgCrdnEventIntervalList = provider.EventIntervalLists(i)
    ' All event interval lists implement IAgCrdn interface which provides
    ' information about the event interval list's instance and its type.
    Dim crdn As IAgCrdn = TryCast(provider.EventIntervalLists(i), IAgCrdn)
    ' Print the event interval list's name and type to the standard output.
    Console.WriteLine("Name: {0}, type: {1}", crdn.Name, eventIntervalList.Type)
    System.Math.Max(System.Threading.Interlocked.Increment(i),i - 1)
End While
Get Center point and Inertial System of Earth CB
[MATLAB] Copy Code
% IAgStkObjectRoot root: STK Object Model root 
centerPtEarth = root.CentralBodies.Earth.Vgt.Points.Item('Center'); 
icrf = root.CentralBodies.Earth.Vgt.Systems.Item('ICRF'); 
 
 
Get default VGT component on vehicle
[MATLAB] Copy Code
% IAgSatellite satellite: Satellite object 
vgtSat = satellite.vgt; 
% Get handle to the Center point on the satellite 
centerPtSat = vgtSat.Points.Item('Center'); 
% Get handle to the Body Y Vector 
bodyYSat = vgtSat.Vectors.Item('Body.Y'); 
% Get handle to the Body Axes 
bodyAxes = vgtSat.Axes.Item('Body'); 
icrfAxes = vgtSat.Axes.Item('ICRF'); 
 
 
Create a new Displacement Vector
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnPoint centerPtSat: point component 
% IAgCrdnPoint centerPtEarth: point component 
VectFactory = vgtSat.Vectors.Factory; 
Sat2EarthCenter = VectFactory.CreateDisplacementVector('Sat2EarthCenter',centerPtSat,centerPtEarth); 
 
 
Create a new Fixed in Axes Vector
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnAxes bodyAxes: axes component 
VectFactory = vgtSat.Vectors.Factory; 
fixedAxesVector = VectFactory.Create('FixedInAxes','','eCrdnVectorTypeFixedInAxes'); 
fixedAxesVector.ReferenceAxes.SetAxes(bodyAxes); 
fixedAxesVector.Direction.AssignXYZ(0,0,1); 
 
 
Create a new Cross Product Vector
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnVectorDisplacement Sat2EarthCenter: vector component 
% IAgCrdnVectorDisplacement fixedAxesVector: vector component 
VectFactory = vgtSat.Vectors.Factory; 
lineOfNodesVector = VectFactory.CreateCrossProductVector('CrossProduct',Sat2EarthCenter,fixedAxesVector); 
 
 
Create a new Custom Script Vector
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
VectFactory = vgtSat.Vectors.Factory; 
customScript = VectFactory.Create('Script','Description','eCrdnVectorTypeCustomScript'); 
% Initialization script if needed 
% customScript.InitializationScriptFile = ''; 
customScript.ScriptFile = 'C:\Program Files\AGI\STK 11\CodeSamples\Extend\PluginScripts\VB_CustomVector.vbs'; 
if customScript.IsValid == false 
    disp('Script component not valid!'); 
    disp(['Copy vbs file from C:\Program Files\AGI\STK 11\CodeSamples\Extend\PluginScripts\VB_CustomVector.vbs to C:\Users\' getenv('USERNAME') '\Documents\STK 11\Config\Scripting\VectorTool']); 
end 
 
 
Create a new Projection Vector
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnVectorDisplacement Sat2EarthCenter: vector component 
VectFactory = vgtSat.Vectors.Factory; 
projectionVector = VectFactory.Create('Projection','','eCrdnVectorTypeProjection'); 
projectionVector.Source.SetVector(Sat2EarthCenter); 
horizontalPlane = vgtSat.Planes.Item('LocalHorizontal'); 
projectionVector.ReferencePlane.SetPlane(horizontalPlane); 
 
 
Create a new Fixed in System Point
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
PtFactory = vgtSat.Points.Factory; 
fixedPt = PtFactory.Create('FixedPt','Point offest from Center','eCrdnPointTypeFixedInSystem'); 
fixedPt.FixedPoint.AssignCartesian(.005,0,.005); 
 
 
Create a new Central Body Intersection Point
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnPoint centerPtSat: point component 
PtFactory = vgtSat.Points.Factory; 
cbIntersectPt = PtFactory.Create('CBIntersectPt','Point on surface along nadir vector','eCrdnPointTypeCentralBodyIntersect'); 
cbIntersectPt.CentralBody = 'Earth'; 
cbIntersectPt.ReferencePoint = centerPtSat; 
cbIntersectPt.DirectionVector = vgtSat.Vectors.Item('Nadir(Detic)'); 
cbIntersectPt.IntersectionSurface = 'eCrdnIntersectionSurfaceAtCentralBodyEllipsoid'; 
 
 
Create a new Model Attachment Point
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
PtFactory = vgtSat.Points.Factory; 
modelPt = PtFactory.Create('ModelPt','Attach point defined in model','eCrdnPointTypeModelAttachment'); 
modelPt.PointableElementName = 'MainSensor-000000'; 
 
 
Create a new Fixed at Time Instant Point
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnSystemAssembled icrf: system component 
PtFactory = vgtSat.Points.Factory; 
timeInstantPt = PtFactory.Create('AtTimePt','Point at time instant','eCrdnPointTypeAtTimeInstant'); 
timeInstantPt.SourcePoint = vgtSat.Points.Item('Center'); 
timeInstantPt.ReferenceSystem = icrf; 
timeInstantPt.ReferenceTimeInstant = vgtSat.Events.Item('AvailabilityStartTime'); 
 
 
Create a new Between Vectors Angle
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnVectorDisplacement Sat2EarthCenter: vector component 
% IAgCrdnVectorFixedInAxes bodyYSat: vector component 
AngFactory = vgtSat.Angles.Factory; 
betwVect = AngFactory.Create('SatEarth2Y','Displacement Vector to Sat Body Y','eCrdnAngleTypeBetweenVectors'); 
betwVect.FromVector.SetVector(Sat2EarthCenter); 
betwVect.ToVector.SetVector(bodyYSat); 
 
 
Create a new Aligned and Constrained Axes
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnVectorDisplacement Sat2EarthCenter: vector component 
% IAgCrdnVectorFixedInAxes bodyYSat: vector component 
AxesFactory = vgtSat.Axes.Factory; 
AlignConstain = AxesFactory.Create('AlignConstrain','Aligned to displacement vector and constrained to Body Y','eCrdnAxesTypeAlignedAndConstrained'); 
AlignConstain.AlignmentReferenceVector.SetVector(Sat2EarthCenter); 
AlignConstain.AlignmentDirection.AssignXYZ(1,0,0); 
AlignConstain.ConstraintReferenceVector.SetVector(bodyYSat); 
AlignConstain.constraintDirection.AssignXYZ(0,0,1); 
 
 
Create a new Fixed in Axes
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgStkObjectRoot root: STK Object Model root 
AxesFactory = vgtSat.Axes.Factory; 
fixed = AxesFactory.Create('Fixed','Axes fixed in Earth Fixed frame using Euler 321 sequence','eCrdnAxesTypeFixed'); 
earthFixed = root.CentralBodies.Earth.Vgt.Axes.Item('Fixed'); 
fixed.ReferenceAxes.SetAxes(earthFixed); 
fixed.FixedOrientation.AssignEulerAngles('e321',45,35,0); 
 
 
Create a new Assembled System
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnPointFixedInSystem fixedPt: point component 
% IAgCrdnAxes bodyAxes: axes component 
SysFactory = vgtSat.Systems.Factory; 
assemSys = SysFactory.Create('FixedPtSystem','System with origin at the new point','eCrdnSystemTypeAssembled'); 
assemSys.OriginPoint.SetPoint(fixedPt); 
assemSys.ReferenceAxes.SetAxes(bodyAxes); 
 
 
Create a new Quadrant Plane
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnSystemAssembled icrf: system component 
PlaneFactory = vgtSat.Planes.Factory; 
yzQuad = PlaneFactory.Create('YZQuad','YZ Quadrant','eCrdnPlaneTypeQuadrant'); 
yzQuad.ReferenceSystem.SetSystem(icrf); 
yzQuad.Quadrant = 'eCrdnQuadrantYZ'; 
 
 
Create a new Vector Magnitude Scalar
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnVectorDisplacement Sat2EarthCenter: vector component 
calcFactory = vgtSat.CalcScalars.Factory; 
displScalar = calcFactory.CreateCalcScalarVectorMagnitude('VectorDisplacement','Vector Magnitude of Displacement Vector'); 
displScalar.InputVector = Sat2EarthCenter; 
 
 
Create a Data Element Scalar
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
calcFactory = vgtSat.CalcScalars.Factory; 
trueAnom = calcFactory.Create('TrueAnomaly','','eCrdnCalcScalarTypeDataElement'); 
trueAnom.SetWithGroup('Classical Elements','ICRF','True Anomaly'); 
 
 
Create a Function XY Scalar
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnCalcScalar displScalar: calc scalar component 
% IAgCrdnCalcScalar trueAnom: calc scalar component 
calcFactory = vgtSat.CalcScalars.Factory; 
functionScalar = calcFactory.CreateCalcScalarFunction2Var('FunctionXY','Difference between the 2 scalars'); 
 
functionScalar.X = displScalar; 
functionScalar.Y = trueAnom; 
functionScalar.A = 1; 
functionScalar.B = 1; 
functionScalar.C = 1; 
functionScalar.SelectedFunction = 'a*x-b*y'; 
functionScalar.OutputDimensionInheritance = 'eCrdnDimensionInheritanceFromX'; 
 
 
Get a Scalar component and evaluate at a time
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgScenario scenario: Scenario object 
deticLatitude = vgtSat.CalcScalars.Item('GroundTrajectory.Detic.LLA.Latitude'); 
result = deticLatitude.Evaluate(scenario.StartTime); 
disp(['The value of detic latitude is ' result.Value]); 
 
 
Create a new Condition
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnCalcScalarDataElement trueAnom: calc scalar component 
condFactory = vgtSat.Conditions.Factory; 
scaleBound = condFactory.Create('BelowMax','Valid for displacement','eCrdnConditionTypeScalarBounds'); 
scaleBound.Scalar = trueAnom; 
scaleBound.Operation = 'eCrdnConditionThresholdOptionBelowMax'; 
maxValue = root.ConversionUtility.NewQuantity('Angle', 'deg', 180); 
scaleBound.SetMaximum(maxValue); %Maximum 
 
 
Create a new Attitude Parameter Set
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnAxes bodyAxes: axes component 
% IAgCrdnAxes icrfAxes: axes component 
paraFactory = vgtSat.ParameterSets.Factory; 
paraSet = paraFactory.Create('attitudeICRF','Attitude Set','eCrdnParameterSetTypeAttitude'); 
paraSet.Axes = bodyAxes; 
paraSet.ReferenceAxes = icrfAxes; 
 
 
Create a new Orbit Parameter Set
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
paraFactory = vgtSat.ParameterSets.Factory; 
paraSetOribit = paraFactory.Create('orbitSun','Orbit','eCrdnParameterSetTypeOrbit'); 
paraSetOribit.OrbitingPoint = vgtSat.Points.Item('Center'); 
paraSetOribit.CentralBody = 'Sun'; 
paraSetOribit.UseCentralBodyGravitationalParameter = false; 
paraSetOribit.GravitationalParameter = 398600; %km^3/sec^2 
 
 
Get Times From Defined Time Instant and create an cell array
[MATLAB] Copy Code
% IAgStkObjectRoot root: STK Object Model Root 
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% Change DateFormat dimension to epoch seconds to make the time easier to handle in 
% MATLAB 
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec'); 
satStart= vgtSat.Events.Item('AvailabilityStartTime'); 
start = satStart.FindOccurrence.Epoch; 
 
satStop= vgtSat.Events.Item('AvailabilityStopTime'); 
stop = satStop.FindOccurrence.Epoch; 
interval = {start 540 600 stop}';   %EpSec 
 
 
Create a new Time Instant
[MATLAB] Copy Code
% IAgStkObjectRoot root: STK Object Model Root 
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% Change DateFormat dimension to epoch seconds to make the time easier to handle in 
% MATLAB 
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec'); 
timeInstFactory = vgtSat.Events.Factory; 
timeEpoch = timeInstFactory.CreateEventEpoch('FixedTime','Fixed Epoch Time'); 
timeEpoch.Epoch = 3600; 
 
 
Create a new Time Interval
[MATLAB] Copy Code
% IAgStkObjectRoot root: STK Object Model Root 
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% Change DateFormat dimension to epoch seconds to make the time easier to handle in 
% MATLAB 
root.UnitPreferences.Item('DateFormat').SetCurrentUnit('EpSec'); 
timeIntFactory = vgtSat.EventIntervals.Factory; 
timeInterval = timeIntFactory.CreateEventIntervalFixed('TimeInterval','Fixed time interval'); 
timeInterval.SetInterval(60,120); 
 
 
Create a new Interval List
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% 2(n) x 1 cell interval: cell of time values 
timeListFactory = vgtSat.EventIntervalLists.Factory; 
custom = timeListFactory.Create('Custom','','eCrdnEventIntervalListTypeFixed'); 
custom.SetIntervals(interval); 
 
 
Create a new Collection of Interval List
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnPoint centerPtSat: point component 
timeCollListFactory = vgtSat.EventIntervalCollections.Factory; 
timeColl = timeCollListFactory.CreateEventIntervalCollectionLighting('LightingList','Collection of lighting intervals'); 
timeColl.UseObjectEclipsingBodies = true; 
timeColl.Location = centerPtSat; 
 
 
Create a new Time Array
[MATLAB] Copy Code
% IAgCrdnProvider vgtSat: Vector Geometry Tool Interface 
% IAgCrdnEventIntervalListFixed custom: interval list component 
timeArrayFactory = vgtSat.EventArrays.Factory; 
timeArray = timeArrayFactory.CreateEventArrayStartStopTimes('StartTimes','Start Times of Custom Intervals'); 
timeArray.ReferenceIntervals = custom; 
timeArray.StartStopOption = 'eCrdnStartStopOptionCountStartOnly'; 
 
 
© 2016 All Rights Reserved.

STK Programming Interface 11.0.1