Introduction


// Before instantiating AgStkObjectRoot an instance of AgSTKXApplication or an STK X control must be created

AgStkObjectRoot root = new AgStkObjectRoot();

Get a reference to the AgStkObjectRoot using the running STK instance

[C#] Copy Code


// Get reference to running STK instance

AgUiApplication uiApplication = System.Runtime.InteropServices.Marshal.GetActiveObject("STK11.Application") as AgUiApplication;


// Get our IAgStkObjectRoot interface

IAgStkObjectRoot stkRoot = uiApplication.Personality2 as IAgStkObjectRoot;

Get a reference to the AgStkObjectRoot with display alerts turned off.

[C#] Copy Code


// Get reference to running STK instance

AgUiApplication uiApplication = System.Runtime.InteropServices.Marshal.GetActiveObject("STK11.Application") as AgUiApplication;


//Create a new instance of the application model root object.

AgUiApplication uiApplication2 = uiApplication.CreateApplication() as AgUiApplication;


//Set DisplayAlerts to false to suppress certain alerts and messages.

//This is useful when automating tasks.

uiApplication2.DisplayAlerts = false;


// Get our IAgStkObjectRoot interface with display alerts turned off

IAgStkObjectRoot stkRoot = uiApplication2.Personality2 as IAgStkObjectRoot;

Start STK and get a reference to IAgStkObjectRoot

[C#] Copy Code


// Create an instance of STK

AgUiApplication uiApplication = new AgUiApplication();

uiApplication.LoadPersonality("STK");

uiApplication.Visible = true;


// Get our IAgStkObjectRoot interface

IAgStkObjectRoot stkRoot = uiApplication.Personality2 as IAgStkObjectRoot;

Create an area target (on the current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root


// Create the AreaTarget on the current scenario central body (use

// NewOnCentralBody to specify explicitly the central body)

IAgAreaTarget areaTarget = root.CurrentScenario.Children.New(AgESTKObjectType.eAreaTarget, "MyAreaTarget") as IAgAreaTarget;

Define area target boundary and position from list of lat/lon/alt

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root

// IAgAreaTarget areaTarget: AreaTarget object


// By using the fine grained interfaces,

// BeginUpdate/EndUpdate prevent intermediate redraws

root.BeginUpdate();

areaTarget.AreaType = AgEAreaType.ePattern;

IAgAreaTypePatternCollection patterns = areaTarget.AreaTypeData as IAgAreaTypePatternCollection;

patterns.Add(48.897, 18.637);

patterns.Add(46.534, 13.919);

patterns.Add(44.173, 21.476);

root.EndUpdate();

Define area target boundary and position from list of lat/lon/alt (using common tasks)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root

// IAgAreaTarget areaTarget: AreaTarget object


// By using the CommonTasks interface,

// make an array of lattitude and longitude boundary points

Array boundary = new object[,]

    {

        { 48.897, 18.637 },

        { 46.534, 13.919 },

        { 44.173, 21.476 }

    };


// SetAreaTypePattern expects a two dimensional array of latitude and longitude values

areaTarget.CommonTasks.SetAreaTypePattern(ref boundary);

List all points in an area target

[C#] Copy Code

// IAgAreaTarget areaTarget: AreaTarget object


if (areaTarget.AreaType == AgEAreaType.ePattern)

{

    // Get IAgAreaTypePatternCollection interface from AreaTypeData

    IAgAreaTypePatternCollection patternPoints = areaTarget.AreaTypeData as IAgAreaTypePatternCollection;


    // ToArray returns a two dimensional array of latitude and longitude points

    Array areaTargetPoints = patternPoints.ToArray();


    Console.WriteLine("All points in Area Target");

    for (int i = 0; i < areaTargetPoints.GetLength(0); ++i)

    {

        Console.WriteLine("  Latitude {0} Longitude: {1}",

            Convert.ToDouble(areaTargetPoints.GetValue(i, 0)),

            Convert.ToDouble(areaTargetPoints.GetValue(i, 1)));

    }

}

Set an elliptical area target

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root

// IAgAreaTarget areaTarget: AreaTarget object


// By using the fine grained interfaces,

// BeginUpdate/EndUpdate prevent intermediate redraws

root.BeginUpdate();

areaTarget.AreaType = AgEAreaType.eEllipse;

IAgAreaTypeEllipse ellipse = areaTarget.AreaTypeData as IAgAreaTypeEllipse;

ellipse.SemiMajorAxis = 85.25; // in km (distance dimension)

ellipse.SemiMinorAxis = 80.75; // in km (distance dimension)

ellipse.Bearing = 44; // in deg (angle dimension)

root.EndUpdate();

Set an elliptical area target (using common tasks)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root

// IAgAreaTarget areaTarget: AreaTarget object


// By using the CommonTasks interface

areaTarget.CommonTasks.SetAreaTypeEllipse(85.25, 80.75, 44);

Configure the chain compute time period.

[C#] Copy Code

// IAgChain chain: Chain object


chain.SetTimePeriodType(AgEChTimePeriodType.eUserSpecifiedTimePeriod);

IAgChUserSpecifiedTimePeriod userSpecifiedTimePeriod = chain.TimePeriod as IAgChUserSpecifiedTimePeriod;

userSpecifiedTimePeriod.TimeInterval.SetExplicitInterval("1 May 2015 04:00:00.000", "1 May 2015 05:00:00.000");

Create a chain (on the current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root


// Create the Chain on the current scenario central body (use

// NewOnCentralBody to specify explicitly the central body)

IAgChain chain = root.CurrentScenario.Children.New(AgESTKObjectType.eChain, "MyChain") as IAgChain;

Define and compute a chain (advance)

[C#] Copy Code

// IAgChain chain: Chain object


// Remove all previous accesses

chain.ClearAccess();


// Add some objects to chain

chain.Objects.Add("Facility/fac1");

chain.Objects.Add("Satellite/sat1");

chain.Objects.Add("Satellite/sat2");

chain.Objects.Add("Aircraft/air1");


// Configure chain parameters

chain.AutoRecompute = false;

chain.EnableLightTimeDelay = false;

chain.TimeConvergence = 0.001;

chain.DataSaveMode = AgEDataSaveMode.eSaveAccesses;


// Specify our own time period

chain.SetTimePeriodType(AgEChTimePeriodType.eUserSpecifiedTimePeriod);


// Get chain time period interface

IAgChUserSpecifiedTimePeriod chainUserTimePeriod = chain.TimePeriod as IAgChUserSpecifiedTimePeriod;

chainUserTimePeriod.SetTimePeriod("1 Jul 2005 12:00:00", "2 Jul 2005 12:00:00");


// Compute the chain

chain.ComputeAccess();

Define and compute a chain (basic)

[C#] Copy Code

// IAgChain chain: Chain object


// Add some objects to chain (using STK path)

chain.Objects.Add("Facility/fac1");

chain.Objects.Add("Satellite/sat1");

chain.Objects.Add("Satellite/sat2");

chain.Objects.Add("Aircraft/air1");


// Compute the chain

chain.ComputeAccess();

Prints the strand intervals of chain object

[C#] Copy Code

// IAgChain chain: Chain Object


IAgStkObject chainAsStkObject = chain as IAgStkObject;


// Compute the chain access if not done already.

chain.ComputeAccess();


// Considered Start and Stop time

Console.WriteLine("Chain considered start time: {0}", chainAsStkObject.Vgt.Events["ConsideredStartTime"].FindOccurrence().Epoch);

Console.WriteLine("Chain considered stop time: {0}", chainAsStkObject.Vgt.Events["ConsideredStopTime"].FindOccurrence().Epoch);


IAgCrdnEventIntervalCollection objectParticipationIntervals = chainAsStkObject.Vgt.EventIntervalCollections["StrandAccessIntervals"];

IAgCrdnIntervalsVectorResult intervalListResult = objectParticipationIntervals.FindIntervalCollection();


for (int i = 0; i < intervalListResult.IntervalCollections.Count; ++i)

{

    if (intervalListResult.IsValid)

    {

        Console.WriteLine("Link Name: {0}", objectParticipationIntervals.Labels.GetValue(i));

        Console.WriteLine("--------------");

        for (int j = 0; j < intervalListResult.IntervalCollections[i].Count; ++j)

        {

            object startTime = intervalListResult.IntervalCollections[i][j].Start;

            object stopTime = intervalListResult.IntervalCollections[i][j].Stop;

            Console.WriteLine("Start: {0}, Stop: {1}", startTime, stopTime);

        }

    }

}

Delete a STK Object

[C#] Copy Code

// IAgStkObject stkObject: STK Object to be removed


stkObject.Unload();

Export a STK Object to a file

[C#] Copy Code

// IAgStkObject stkObject: STK Object to be exported

// String outputPath: Output path


string fileNameWithoutExtension = Path.Combine(outputPath, "MySatellite1");

stkObject.Export(fileNameWithoutExtension);

Import an existing STK Object file into an object collection

[C#] Copy Code

// IAgStkObjectCollection col: STK Object Collection

// String stkObjectLocation: Path of STK Object external file


col.ImportObject(stkObjectLocation);

Rename a STK Object

[C#] Copy Code

// IAgStkObject stkObject: STK Object to be renamed


stkObject.InstanceName = "NewObjectName";

Set/Get the STK Object description

[C#] Copy Code

// IAgStkObject stkobject: STK Object


// Set STK Object description

stkobject.LongDescription = "This is a very very very long description";

stkobject.ShortDescription = "This is a short description";


// Get STK Object description

string longDescription = stkobject.LongDescription;

string shortDescription = stkobject.ShortDescription;

Add an access constraint to an STK Object

[C#] Copy Code

// IAgStkObject stkobject: STK Object


IAgAccessConstraintCollection accessConstraints = stkobject.AccessConstraints;


// Add constraints

accessConstraints.AddConstraint(AgEAccessConstraints.eCstrSunElevationAngle);

Add and configure a lighting condition access constraint

[C#] Copy Code

// IAgAccessConstraintCollection accessConstraints: Access Constraint collection


// Condition constraint

IAgAccessCnstrCondition light = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrLighting) as IAgAccessCnstrCondition;

light.Condition = AgECnstrLighting.eDirectSun;

Add and configure a LOS sun exclusion access constraint

[C#] Copy Code

// IAgAccessConstraintCollection accessConstraints: Access Constraint collection


// Angle constraint

IAgAccessCnstrAngle cnstrAngle = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrLOSSunExclusion) as IAgAccessCnstrAngle;

cnstrAngle.Angle = 176.0;

Add and configure a lunar elevation angle access constraint

[C#] Copy Code

// IAgAccessConstraintCollection accessConstraints: Access Constraint collection


IAgAccessCnstrMinMax minmax = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrLunarElevationAngle) as IAgAccessCnstrMinMax;

minmax.EnableMin = true;

minmax.Min = 11.1;

minmax.EnableMax = true;

minmax.Max = 88.8;

Add and configure a sun elevation angle access constraint

[C#] Copy Code

// IAgAccessConstraintCollection accessConstraints: Access Constraint collection


IAgAccessCnstrMinMax minmax = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrSunElevationAngle) as IAgAccessCnstrMinMax;

minmax.EnableMin = true;

minmax.Min = 22.2;

minmax.EnableMax = true;

minmax.Max = 77.7;

Add and configure a third body obstruction access constraint

[C#] Copy Code

// IAgAccessConstraintCollection accessconstraints: Access Constraint collection


// Get IAgAccessCnstrThirdBody interface

IAgAccessCnstrThirdBody thirdBodyConstraint = accessconstraints.AddConstraint(AgEAccessConstraints.eCstrThirdBodyObstruction) as IAgAccessCnstrThirdBody;


// AvailableObstructions returns a one dimensional array of obstruction paths

Array availableArray = thirdBodyConstraint.AvailableObstructions;


// In this example add all available obstructions

Console.WriteLine("Available obstructions");

foreach (string available in availableArray)

{

    Console.WriteLine(available);

    thirdBodyConstraint.AddObstruction(available);

}


// AssignedObstructions returns a one dimensional array of obstruction paths

Array assignedArray = thirdBodyConstraint.AssignedObstructions;


Console.WriteLine("Assigned obstructions");

foreach (string assigned in assignedArray)

{

    Console.WriteLine(assigned);

}

Add and configure an altitude access constraint

[C#] Copy Code

// IAgAccessConstraintCollection accessConstraints: Access Constraint collection


// Attitude constraint

IAgAccessCnstrMinMax altitude = accessConstraints.AddConstraint(AgEAccessConstraints.eCstrAltitude) as IAgAccessCnstrMinMax;

altitude.EnableMin = true;

altitude.Min = 20.5;

Add multiple access constraints of the same type to an STK Object

[C#] Copy Code

// IAgStkObject stkobject: STK Object


IAgAccessConstraintCollection accessConstraints = stkobject.AccessConstraints;


// Add constraints

// Only the eCstrApparentTime, eCstrDuration, eCstrGMT, eCstrIntervals, eCstrLocalTime constraint

// types can be added multiple times to the constraint collection.

accessConstraints.AddConstraint(AgEAccessConstraints.eCstrLocalTime);

accessConstraints.AddConstraint(AgEAccessConstraints.eCstrLocalTime);

Compute an access and get constraint data from data provider

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Compute Access between the facility and the satellite

IAgStkObject sat1 = root.GetObjectFromPath("Satellite/Satellite1");

IAgStkObject fac1 = root.GetObjectFromPath("Facility/Facility1");

IAgStkAccess access = sat1.GetAccessToObject(fac1);

access.ComputeAccess();


// Get the access intervals

IAgIntervalCollection accessIntervals = access.ComputedAccessIntervalTimes;


// Set unit preferences - change to get your preferred units

root.UnitPreferences.SetCurrentUnit("Distance", "km");

root.UnitPreferences.SetCurrentUnit("Angle", "deg");

root.UnitPreferences.SetCurrentUnit("Time", "sec");

root.UnitPreferences.SetCurrentUnit("DateFormat", "UTCG");


// Extract the access intervals and the range information for each access interval

Array dataPrvElements = new object[]

    {

        "Time", "FromAngularRate", "FromRange"

    };


IAgDataPrvTimeVar dp = access.DataProviders["Constraint Data"] as IAgDataPrvTimeVar;


for (int index0 = 0; index0 < accessIntervals.Count; ++index0)

{

    object startTime = null, stopTime = null;


    accessIntervals.GetInterval(index0, out startTime, out stopTime);


    Console.WriteLine("Access Interval #{0} - Start={1} Stop={2}", index0, startTime, stopTime);


    IAgDrResult result = dp.ExecElements(startTime, stopTime, 60, ref dataPrvElements);


    Array timeValues = result.DataSets[0].GetValues();

    Array fromAngularRateValues = result.DataSets[1].GetValues();

    Array fromRangeValues = result.DataSets[2].GetValues();


    for (int index1 = 0; index1 < timeValues.GetLength(0); ++index1)

    {

        Console.WriteLine("{0}: FromAngularRate={1} FromRange={2}",

            timeValues.GetValue(index1),

            fromAngularRateValues.GetValue(index1),

            fromRangeValues.GetValue(index1));

    }


    Console.WriteLine();

}

Compute an access between two STK Objects (using IAgStkObject interface)

[C#] Copy Code

// IAgStkObject stkObject1: STK Object

// IAgStkObject stkObject2: STK Object


// Get access by STK Object

IAgStkAccess access = stkObject1.GetAccessToObject(stkObject2);


// Compute access

access.ComputeAccess();

Compute an access between two STK Objects (using object path)

[C#] Copy Code

// IAgStkObject stkObject: STK Object


// Get access by object path

IAgStkAccess access = stkObject.GetAccess("Facility/fac1");


// Compute access

access.ComputeAccess();

Compute an access for one point

[C#] Copy Code

// IAgStkObject facility: Facility object


IAgOnePtAccess onePtAccess = facility.CreateOnePointAccess("Satellite/Satellite1");


// Configure properties (if necessary)

onePtAccess.StartTime = "1 Jan 2012 12:00:00.000";

onePtAccess.StopTime = "1 Jan 2012 13:00:00.000";

onePtAccess.StepSize = 120;

onePtAccess.SummaryOption = AgEOnePtAccessSummary.eOnePtAccessSummaryDetailed;


// Compute results

IAgOnePtAccessResultCollection results = onePtAccess.Compute();


// Print results

for (int i = 0; i < results.Count; i++)

{

    IAgOnePtAccessResult result = results[i];


    Console.WriteLine("Time: {0}, HasAccess: {1}", result.Time, result.AccessSatisfied);


    for (int j = 0; j < result.Constraints.Count; j++)

    {

        IAgOnePtAccessConstraint constraint = result.Constraints[j];

        Console.WriteLine("Constraint: {0}, Object {1}, Status {2}, Value {3}",

            constraint.Constraint,

            constraint.ObjectPath,

            constraint.Status,

            constraint.Value);

    }

}

Compute and extract access interval times

[C#] Copy Code

// IAgStkAccess access: Access calculation


// Get and display the Computed Access Intervals

IAgIntervalCollection intervalCollection = access.ComputedAccessIntervalTimes;


// Set the intervals to use to the Computed Access Intervals

Array computedIntervals = intervalCollection.ToArray(0, -1);

access.SpecifyAccessIntervals(ref computedIntervals);

Configure the access analysis time period to specified time instants.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgStkObject uav = stkRoot.GetObjectFromPath("/Aircraft/UAV");

IAgStkObject sensor = stkRoot.GetObjectFromPath("/Aircraft/UAV/Sensor/UAVSensor");

IAgStkObject coloradoSprings = stkRoot.GetObjectFromPath("/Place/ColoradoSprings");


// For this code snippet, let's use the time interval when the UAV reached min and max altitude values.

// Note, this assumes time at min happens before time at max.

IAgCrdnEvent timeOfAltMin = uav.Vgt.Events["GroundTrajectory.Detic.LLA.Altitude.TimeOfMin"];

IAgCrdnEvent timeOfAltMax = uav.Vgt.Events["GroundTrajectory.Detic.LLA.Altitude.TimeOfMax"];


// Set the access time period with the times we figured out above.

IAgStkAccess access = sensor.GetAccessToObject(coloradoSprings);

access.AccessTimePeriod = AgEAccessTimeType.eUserSpecAccessTime;

IAgAccessTimePeriod accessTimePeriod = access.AccessTimePeriodData as IAgAccessTimePeriod;


accessTimePeriod.AccessInterval.State = AgECrdnSmartIntervalState.eCrdnSmartIntervalStateStartStop;


IAgCrdnEventSmartEpoch accessStartEpoch = accessTimePeriod.AccessInterval.GetStartEpoch();

accessStartEpoch.SetImplicitTime(timeOfAltMin);

accessTimePeriod.AccessInterval.SetStartEpoch(accessStartEpoch);


IAgCrdnEventSmartEpoch accessStopEpoch = accessTimePeriod.AccessInterval.GetStopEpoch();

accessStopEpoch.SetImplicitTime(timeOfAltMax);

accessTimePeriod.AccessInterval.SetStopEpoch(accessStopEpoch);

Configure the access interval to the availability time span of the object where access is being computed to.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgStkObject satellite = stkRoot.GetObjectFromPath("/Satellite/GEO");

IAgStkObject otherObject = stkRoot.GetObjectFromPath("/Aircraft/UAV/Sensor/UAVSensor");

IAgStkAccess access = satellite.GetAccessToObject(otherObject);


access.AccessTimePeriod = AgEAccessTimeType.eUserSpecAccessTime;

IAgAccessTimePeriod accessTimePeriod = access.AccessTimePeriodData as IAgAccessTimePeriod;


if (otherObject.Vgt.EventIntervals.Contains("AvailabilityTimeSpan"))

{

    IAgCrdnEventInterval availabilityTimeSpan = otherObject.Vgt.EventIntervals["AvailabilityTimeSpan"];

    accessTimePeriod.AccessInterval.SetImplicitInterval(availabilityTimeSpan);

}

Enumerate the available constraints collection

[C#] Copy Code

// IAgAccessConstraintCollection accessConstraints: Access Constraint collection


// The AvailableConstraints method returns a rectangular two-dimensional array of available constraints.

// A row of the array consists of two elements where the first element is a symbolic name of the constraint,

// and the second is a corresponding enumeration value.


Array arAvailable = accessConstraints.AvailableConstraints();

for (int i = 0; i < arAvailable.GetLength(0); i++)

{

    string availName = (string)arAvailable.GetValue(i, 0);

    AgEAccessConstraints eAccessConstraint = (AgEAccessConstraints)(int)arAvailable.GetValue(i, 1);

    Console.WriteLine("\tConstraint {0}: {1} ({2})", i, availName, eAccessConstraint);

}

GetAccessBetweenObjectsByPath using the output of GetExistingAccesses

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgScenario scenario = stkRoot.CurrentScenario as IAgScenario;

Array accesses = scenario.GetExistingAccesses();


int numAccesses = accesses.GetLength(0);  // number of accesses


string object1 = accesses.GetValue(0, 0).ToString();    // e.g. "Facility/Fac1"

string object2 = accesses.GetValue(0, 1).ToString();    // e.g. "Satellite/Sat1"

bool computed = (bool)accesses.GetValue(0, 2);          // e.g. true  (if access has been computed)


IAgStkAccess access = scenario.GetAccessBetweenObjectsByPath(object1, object2);

List all exclusion zones of an access constraint

[C#] Copy Code

// IAgAccessConstraintCollection accessconstraints: Access Constraint collection


IAgAccessCnstrExclZonesCollection excZones = accessconstraints.GetActiveConstraint(AgEAccessConstraints.eCstrExclusionZone) as IAgAccessCnstrExclZonesCollection;


if (excZones != null)

{

    // ToArray returns a two dimensional array

    // The second dimension is an array of minLon, minLat, maxLon, maxLat values

    Array zones = excZones.ToArray(0, -1);


    for (int i = 0; i < zones.GetUpperBound(0); i++)

    {

        Console.WriteLine("MinLon: {0}, MinLat: {1}, MaxLon: {2}, MaxLat {3}", zones.GetValue(i, 0), zones.GetValue(i, 1), zones.GetValue(i, 2), zones.GetValue(i, 3));

    }

}

Remove an access constraint from a STK Object

[C#] Copy Code

// IAgStkObject stkobject: STK Object


IAgAccessConstraintCollection accessConstraints = stkobject.AccessConstraints;


// Remove constraints

accessConstraints.RemoveConstraint(AgEAccessConstraints.eCstrSunElevationAngle);

Coarse grain approach to retrieving a fixed data provider

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgStkObject facility: STK Object that contains fixed data provider


IAgDataPrvFixed dp = facility.DataProviders.GetDataPrvFixedFromPath("Terrain Info//LocalHorizontal");

IAgDrResult result = dp.Exec();

Coarse grain approach to retrieving a interval data provider

[C#] Copy Code

// IAgStkObject facility: STK Object


IAgDataPrvInterval dp = facility.DataProviders.GetDataPrvIntervalFromPath("Lighting Times//Sunlight");

IAgDrResult result = dp.Exec("1 Jan 2012 12:00:00.000", "1 Jan 2012 12:00:20.000");

Coarse grain approach to retrieving a time var data provider

[C#] Copy Code

// IAgStkObject facility: STK Object


IAgDataPrvTimeVar dp = facility.DataProviders.GetDataPrvTimeVarFromPath("Lighting AER");

IAgDrResult result = dp.Exec(

    "1 Jan 2012 12:00:00.000",

    "1 Jan 2012 12:00:20.000",

    60.0);

Coarse grain approach to retrieving data provider information

[C#] Copy Code

// IAgStkObject facility: Facility STK Object


// The path separator is //

IAgDataProviderInfo dp = facility.DataProviders.GetDataPrvInfoFromPath("Lighting Times//Sunlight");

string dpiName              = dp.Name;

AgEDataProviderType dpiType = dp.Type;

bool isGroup                = dp.IsGroup();

Execute a non time dependent data provider (for instance facility position)

[C#] Copy Code

// IAgStkObject facility: STK Object


IAgDataPrvFixed dpInfo = facility.DataProviders["Cartesian Position"] as IAgDataPrvFixed;

IAgDrResult resInfo = dpInfo.Exec();

Execute a non time dependent data provider (for instance facility position) and request only the specified elements

[C#] Copy Code

// IAgStkObject facility: STK Object


Array elems = new object[]

              {

                  "x", "z"

              };


IAgDataPrvFixed dpInfo = facility.DataProviders["Cartesian Position"] as IAgDataPrvFixed;


// ExecElements expects a one dimensional array of element names

IAgDrResult resInfo = dpInfo.ExecElements(ref elems);

Execute a time dependent data provider and request all elements for the specified time interval

[C#] Copy Code

// IAgStkObject facility: STK Object


IAgDataPrvTimeVar dpInfo = facility.DataProviders["Lighting AER"] as IAgDataPrvTimeVar;

IAgDrResult resInfo = dpInfo.Exec(

    "1 Jan 2012 12:00:00.000",

    "1 Jan 2012 12:00:20.000",

    60.0);

Execute a time dependent data provider and returning all elements for a single time

[C#] Copy Code

// IAgStkObject satellite: STK Object


IAgDataPrvTimeVar dp = satellite.DataProviders["Precision Passes"] as IAgDataPrvTimeVar;

IAgDrResult resInfo = dp.ExecSingle("1 Jan 2012 12:00:00.000");

Execute a time dependent data provider and returning the specified elements at the specified time

[C#] Copy Code

// IAgStkObject satellite: STK Object


Array times = new object[]

              {

                  "1 Jan 2012 12:00:00.000", "1 Jan 2012 12:00:20.000",

                  "1 Jan 2012 12:00:40.000"

              };

Array elems = new object[]

              {

                  "Time",

                  "Precision Pass Number"

              };


IAgDataPrvTimeVar dp = satellite.DataProviders["Precision Passes"] as IAgDataPrvTimeVar;


// ExecSingleElementsArray expects each safe array parameter to be one dimensional,

// all arrays must have the same length

IAgDrTimeArrayElements resInfo = dp.ExecSingleElementsArray(ref times, ref elems);

Execute a time dependent data provider and returning the specified elements for a single time

[C#] Copy Code

// IAgStkObject satellite: STK Object


Array elems = new object[]

              {

                  "Time",

                  "Precision Pass Number"

              };


IAgDataPrvTimeVar dp = satellite.DataProviders["Precision Passes"] as IAgDataPrvTimeVar;


// ExecSingleElements expects as the second parameter a one dimensional array of element names

IAgDrResult resInfo = dp.ExecSingleElements("1 Jan 2012 12:00:00.000", ref elems);

Execute a time dependent data provider which uses preData and returning the specified elements

[C#] Copy Code

// IAgStkObject satObj: Satellite STK Object


Array elems = new object[]

{ "Range", "Radial Rate" };

IAgDataPrvTimeVar RICdp = satObj.DataProviders["Relative Motion"] as IAgDataPrvTimeVar;

(RICdp as IAgDataProvider).PreData = "Satellite/Satellite123";

IAgDrResult result = RICdp.ExecElements("26 Jan 2015 17:00:00.000", "27 Jan 2015 17:00:00.000", 120, ref elems);

IAgDrDataSetCollection datasets = result.DataSets;


if (result.DataSets.Count > 0)

{

    System.Array arrayRange = datasets[0].GetValues();

    System.Array arrayRadialRate = datasets[1].GetValues();

}

Execute a time dependent group data provider which uses preData and returning the specified elements

[C#] Copy Code

// IAgStkObject satObj: Satellite STK Object


Array elems = new object[]

{ "Time", "x", "y", "z" };

IAgDataProviderGroup dpVectorChoose = satObj.DataProviders["Vector Choose Axes"] as IAgDataProviderGroup;

IAgDataProvider groupPosition = dpVectorChoose.Group["Position"] as IAgDataProvider;

groupPosition.PreData = "Satellite/Sat2 Body";

IAgDataPrvTimeVar timeVarDP = groupPosition as IAgDataPrvTimeVar;

IAgDrResult result = timeVarDP.ExecElements("26 Jan 2015 17:00:00.000", "27 Jan 2015 17:00:00.000", 120, ref elems);

IAgDrDataSetCollection datasets = result.DataSets;


if (result.DataSets.Count > 0)

{

    System.Array arrayTime = datasets[0].GetValues();

    System.Array arrayX = datasets[1].GetValues();

    System.Array arrayY = datasets[2].GetValues();

    System.Array arrayZ = datasets[2].GetValues();

}

Execute an interval data provider (for instance access times) and returning all elements

[C#] Copy Code

// IAgStkObject satellite: Satellite STK Object

// IAgStkObject areatarget: Area Target STK Object


IAgStkAccess Access = satellite.GetAccessToObject(areatarget) as IAgStkAccess;

Access.ComputeAccess();


IAgDataPrvInterval dpInfo = Access.DataProviders["Access Data"] as IAgDataPrvInterval;


IAgDrResult resInfo = dpInfo.Exec(

    "1 Jan 2012 12:00:00.000",

    "2 Jan 2012 12:00:00.000");

Execute an interval data provider (for instance access times) and returning only the specified elements

[C#] Copy Code

// IAgStkObject satellite: Satellite STK Object

// IAgStkObject areatarget: Area Target STK Object


IAgStkAccess access = satellite.GetAccessToObject(areatarget) as IAgStkAccess;

access.ComputeAccess();


IAgDataPrvInterval dp = access.DataProviders["Access Data"] as IAgDataPrvInterval;


Array elems = new object[]

              {

                  "Start Time",

                  "Stop Time",

                  "Access Number",

                  "From Pass Number",

                  "To Pass Number",

                  "From Start Alt",

                  "From Stop Alt"

              };


// ExecElements expects the third parameter to be a one dimensional array of element names

IAgDrResult resInfo = dp.ExecElements(

    "1 Jan 2012 12:00:00.000",

    "2 Jan 2012 12:00:00.000",

    ref elems);

Execute an object coverage data provider and dump its result

[C#] Copy Code

// IAgStkObjectRoot root: STK Object


IAgStkObject aircraft = root.CurrentScenario.Children["aircraft340"];


IAgStkObjectCoverage objectCoverage = aircraft.ObjectCoverage;

objectCoverage.Clear();

objectCoverage.Assets.Add("Constellation/gps_const");

objectCoverage.Compute();


IAgDataPrvTimeVar provider = objectCoverage.DataProviders["FOM by Time"] as IAgDataPrvTimeVar;


IAgDrResult result = provider.Exec("1 Jan 2012 12:00:00.00", "1 Jan 2012 13:00:00.00", 1);


foreach (IAgDrSubSection section in result.Sections)

{

    foreach (IAgDrInterval interval in section.Intervals)

    {

        Array arBoundaries = new object[]

                             {

                                 1.0, 2.0, 3.0, 4.0, 5.0

                             };


        // MultipleThresholdCrossings expects the second parameter

        // to be a one demensional array of boundary index values

        Array arRanges = interval.MultipleThresholdCrossings("FOM Value", ref arBoundaries);


        for (int iRange = 0; iRange < arRanges.GetLength(0); iRange++)

        {

            Console.Write("\nRange: {0}\n", iRange);


            Array arTimeSpans = arRanges.GetValue(iRange) as Array;

            for (int iSpan = 0; iSpan < arTimeSpans.GetLength(0); iSpan++)

            {

                string strStart = arTimeSpans.GetValue(iSpan, 0).ToString();

                string strStop = arTimeSpans.GetValue(iSpan, 1).ToString();


                Console.Write("Start: {0} Stop: {1}\n", strStart, strStop);

            }

        }

    }

}

Extract data from IAgDrDataSetCollection (generic)

[C#] Copy Code

// IAgDrDataSetCollection datasets: Data provider data sets


foreach (String name in datasets.ElementNames)

{

    //If the data set collection spans multiple intervals then the GetDataSetByName method will only

    //get the first intervals dataset.  See the Extract data from IAgDrDataSetCollection across

    //multiple intervals code snippet to see how to access all of the data sets in the result.

    IAgDrDataSet dataset = datasets.GetDataSetByName(name);


    Array datasetValues = dataset.GetValues();


    Console.WriteLine("{0}", dataset.ElementName);


    foreach (object value in datasetValues)

    {

        Console.WriteLine("\t{0}", value.ToString());

    }

}

Extract data from IAgDrDataSetCollection across multiple intervals.

[C#] Copy Code

// IAgDrDataSetCollection datasets: Data provider data sets


foreach (IAgDrDataSet set in datasets)

{

    Console.WriteLine("{0}", set.ElementName);

    foreach (object value in set.GetValues())

    {

        Console.WriteLine("\t{0}", value.ToString());

    }

}

Extract data from IAgDrIntervalCollection (generic)

[C#] Copy Code

// IAgDrIntervalCollection intervals: Data provider intervals


// Enumerate IAgDrIntervalCollection collection

foreach (IAgDrInterval interval in intervals)

{

    Console.WriteLine("{0} - {1}", interval.StartTime, interval.StopTime);


    foreach (IAgDrDataSet dataset in interval.DataSets)

    {

        Array values = dataset.GetValues();


        Console.WriteLine("{0}", dataset.ElementName);


        foreach (object value in values)

        {

            Console.WriteLine("\t{0}", value.ToString());

        }

    }

}

Extract data from IAgDrResult based on its category (generic)

[C#] Copy Code

// IAgDrResult result: Data provider result


// Look at the Category property to find out which interface to use

switch (result.Category)

{

    case AgEDrCategories.eDrCatDataSetList:

        IAgDrDataSetCollection datasets = result.DataSets;

        // See IAgDrDataSetCollection inteface

        break;

    case AgEDrCategories.eDrCatIntervalList:

        IAgDrIntervalCollection intervals = result.Intervals;

        // See IAgDrIntervalCollection interface

        break;

    case AgEDrCategories.eDrCatMessage:

        IAgDrTextMessage message = result.Message;

        // See IAgDrTextMessage interface

        break;

    case AgEDrCategories.eDrCatSubSectionList:

        IAgDrSubSectionCollection section = result.Sections;

        // See IAgDrSubSectionCollection interface

        break;

}

Extract data from IAgDrSubSectionCollection (generic)

[C#] Copy Code

// IAgDrSubSectionCollection subSection: Subsection collection


foreach (IAgDrSubSection section in subSection)

{

    Console.WriteLine(section.Title);


    foreach (IAgDrInterval interval in section.Intervals)

    {

        Console.WriteLine("\tTime {0} - {1}", interval.StartTime, interval.StopTime);


        foreach (IAgDrDataSet dataset in interval.DataSets)

        {

            Array values = dataset.GetValues();


            Console.WriteLine("\t{0}", dataset.ElementName);


            foreach (object value in values)

            {

                Console.WriteLine("\t\t{0}", value.ToString());

            }

        }

    }

}

Extract data from IAgDrTextMessage (generic)

[C#] Copy Code

// IAgDrTextMessage message: 


foreach (object messagei in message.Messages)

{

    Console.WriteLine(messagei);

}

Set STK Object Display to always on

[C#] Copy Code

// IAgStkObject stkObject: STK Object


IAgDisplayTm display = stkObject as IAgDisplayTm;

display.SetDisplayStatusType(AgEDisplayTimesType.eAlwaysOn);

Set STK Object Display to use during access mode

[C#] Copy Code

// IAgStkObject stkObject: STK Object


// Attempt to cast STK Object to the IAgDisplayTm interface

IAgDisplayTm display = stkObject as IAgDisplayTm;

if (display != null)

{

    // Configure during access

    if (display.IsDisplayStatusTypeSupported(AgEDisplayTimesType.eDuringAccess))

    {

        display.SetDisplayStatusType(AgEDisplayTimesType.eDuringAccess);


        IAgDuringAccess duringAccess = display.DisplayTimesData as IAgDuringAccess;


        // Add subsequent existing stk objects to access diplay ...

        duringAccess.AccessObjects.Add("Satellite/satellite1");

        duringAccess.AccessObjects.Add("Star/star1");

    }

}

Set STK Object Display to use intervals mode

[C#] Copy Code

// IAgStkObject stkObject: STK Object


// Attempt to cast STK Object to the IAgDisplayTm interface

IAgDisplayTm display = stkObject as IAgDisplayTm;

if (display != null)

{

    // Configure display intervals

    if (display.IsDisplayStatusTypeSupported(AgEDisplayTimesType.eUseIntervals))

    {

        display.SetDisplayStatusType(AgEDisplayTimesType.eUseIntervals);


        // Get IAgIntervalCollection interface

        IAgIntervalCollection intervalCollection = display.DisplayTimesData as IAgIntervalCollection;

        intervalCollection.RemoveAll();


        // Add subsequent intervals...

        intervalCollection.Add(

            "1 Jan 2012 12:00:00.00",

            "1 Jan 2012 13:00:00.000");

    }

}

Set scenario display to hide and show STK Objects in a specified 2D window

[C#] Copy Code

// IAgScenario scenario: Scenario object


IAgScGraphics gfx = scenario.Graphics;


// Individually

gfx.HideObject("Facility/facility1", "all");

gfx.ShowObject("Facility/facility1", "1");


// In Batches

// HideObjects and ShowObjects expects as the first parameter a one dimensional array of object paths

Array objects = new object[]

                {

                    "Facility/facility1",

                    "Facility/facility2"

                };

gfx.HideObjects(ref objects, "1");

gfx.ShowObjects(ref objects, "all");

Configure 3D data display

[C#] Copy Code

// IAgVODataDisplayCollection datadisplaycol: Data Display Collection


// Add existing data display

// See AvailableData property for available data display

IAgVODataDisplayElement displayElement = datadisplaycol.Add("Solar Intensity");


// Configure data display as needed

displayElement.TitleText = "Sol. Intensity";

displayElement.IsVisible = true;

displayElement.Location = AgEVOLocation.e3DWindow;

displayElement.FontColor = Color.White;

displayElement.FontSize = AgEVOFontSize.eSmall;

displayElement.UseBackground = true;

displayElement.BgColor = Color.Orange;

displayElement.UseAutoSizeWidth = false;

displayElement.UseAutoSizeHeight = false;

displayElement.BgHeight = 55;

displayElement.BgWidth = 260;

displayElement.BackgroundTranslucency = 0.5;

displayElement.UseBackgroundTexture = false;

displayElement.UseBackgroundBorder = true;

displayElement.BackgroundBorderColor = Color.White;

Configure 3D model articulations

[C#] Copy Code

// IAgVOModel model: VO Model from an STK Object


// Configure articulation

IAgVOModelArtic modelArticulation = model.Articulation;

modelArticulation.EnableDefaultSave = false;

modelArticulation.EnableSaveArticFile = false;


// Set our articulation and transformations

// For this sample, these articulations exist for a default satellite model

int levelOfDetail = 0;

string articulation = "Satellite";

string transformation = "Size";



// Get the current transition value

double currentTransVal = modelArticulation.GetTransValue(levelOfDetail, articulation, transformation);


// Change the value

double newTransVal = currentTransVal * 0.50;


// Set our new transition value

modelArticulation.SetTransValue(levelOfDetail, articulation, transformation, newTransVal);

Configure 3D model file

[C#] Copy Code

// IAgVOModel model: VO model


// Set new ModelFile.Filename

model.ModelType = AgEModelType.eModelFile;

IAgVOModelFile modelFile = model.ModelData as IAgVOModelFile;

modelFile.Filename = @"\STKData\VO\Models\Space\alexis.mdl";


// Configure basic settings

model.Visible = true;

model.ScaleValue = 4.800;

Configure 3D model level of detail

[C#] Copy Code

// IAgVOModel model: VO Model from an STK Object


// Configure level of details

IAgVODetailThreshold detail = model.DetailThreshold;

detail.EnableDetailThreshold = true;


// (assuming unit preferences set to km)

detail.All = 2.51189;

detail.ModelLabel = 158489;

detail.MarkerLabel = 2.51189e+006;

detail.Marker = 2.511e+007;

detail.Point = 1e+012;

Configure 3D vector

[C#] Copy Code

// IAgVOVector vector: VO Vector


// See AvailableCrdns for supported elements

vector.RefCrdns.Add(AgEGeometricElemType.eVectorElem, ((IAgCrdn)m_Root.CentralBodies["Earth"].Vgt.Vectors["Moon"]).QualifiedPath);

vector.RefCrdns.Add(AgEGeometricElemType.eAxesElem, ((IAgCrdn)m_Root.CentralBodies["Moon"].Vgt.Vectors["Position"]).QualifiedPath);

vector.RefCrdns.Add(AgEGeometricElemType.eVectorElem, ((IAgCrdn)m_Root.CentralBodies["Sun"].Vgt.Vectors["Velocity(Barycenter)"]).QualifiedPath);


// Draw on Central Body

IAgVORefCrdnVector body = vector.RefCrdns.GetCrdnByName(AgEGeometricElemType.eAxesElem, ((IAgCrdn)m_Root.CentralBodies["Earth"].Vgt.Vectors["Moon"]).QualifiedPath) as IAgVORefCrdnVector;

((IAgVORefCrdn)body).Color = Color.Yellow;

body.DrawAtCB = true;

body.Axes = "CentralBody/Earth Fixed Axes";

body.ArrowType = AgEArrowType.e3D;


vector.ScaleRelativeToModel = true;

vector.AngleSizeScale = 4.5;

vector.ArrowPtSize = 11.0;

List all 3D model articulations

[C#] Copy Code

// IAgSatellite satellite: Satellite object

// IAgVOModel model: VO Model from an STK Object


// Enumerating through the transformation collection is helpful if you do not

// know what tranformations exist or their value ranges


IAgVOModelArtic modelArticulation = model.Articulation;


for (int lod = 0; lod < modelArticulation.LODCount; lod++)

{

    // Get all articulations

    // GetAvailableArticulations returns a one dimensional array of articulation names

    Array articulations = modelArticulation.GetAvailableArticulations(lod);


    // Enumerate through available articulations

    for (int articulation = 0; articulation < articulations.Length; articulation++)

    {

        // We need the articulation string to call the GetAvailableTransformations function

        String articulationString = articulations.GetValue(articulation) as String;


        // Get all transformations

        IAgVOModelTransCollection transformations = modelArticulation.GetAvailableTransformations(lod, articulationString);


        // Enumerate through available transformations

        foreach (IAgVOModelTrans trans in transformations)

        {

            Console.WriteLine("Name: {0}, Current {1}, Max {2}, Min {3}", trans.Name, trans.Value, trans.Max, trans.Min);

        }

    }

}

Sets the interval of the object coverage to the sunlight times of an object

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Root


// For this example, set the access times to use the light intervals of the area target.

IAgStkObject uavAircraft = root.GetObjectFromPath("Aircraft/UAV/Sensor/UAV_Camera");

IAgStkObject airspaceAreaTarget = root.GetObjectFromPath("AreaTarget/Airspace");


IAgCrdnEvent firstSunlightEpoch = airspaceAreaTarget.Vgt.Events["LightingIntervals.Sunlight.First.Start"];

IAgCrdnEvent lastSunlightEpoch = airspaceAreaTarget.Vgt.Events["LightingIntervals.Sunlight.First.Stop"];


uavAircraft.ObjectCoverage.UseObjectTimes = false;

IAgCrdnEventSmartEpoch startEpoch = uavAircraft.ObjectCoverage.AccessInterval.GetStartEpoch();

startEpoch.SetImplicitTime(firstSunlightEpoch);


IAgCrdnEventSmartEpoch stopEpoch = uavAircraft.ObjectCoverage.AccessInterval.GetStopEpoch();

stopEpoch.SetImplicitTime(lastSunlightEpoch);


uavAircraft.ObjectCoverage.AccessInterval.SetStartAndStopEpochs(startEpoch, stopEpoch);

Compute a link budget for a Transmtiter and Receiver pair, using complex models

[C#] Copy Code

// IAgTransmitter geoTransmitter: Transmitter object

// IAgReceiver facilityReceiver: Receiver object

// IAgAntenna facilityDish: Antenna object

// IAgRFEnvironment scenarioRFEnv: Scenario RF Environment


IAgStkObject xmtrAsStkObject = geoTransmitter as IAgStkObject;

IAgStkObject rcvrAsStkObject = facilityReceiver as IAgStkObject;


//Enable the rain loss computation on the scenario RF environment

scenarioRFEnv.PropagationChannel.EnableRainLoss = true;


//Set the transmitter to the complex model

geoTransmitter.SetModel("Complex Transmitter Model");

IAgTransmitterModelComplex complexTrans = geoTransmitter.Model as IAgTransmitterModelComplex;


//Set the complex transmitter model's frequency to 3.2 GHz

complexTrans.Frequency = 3.2;


//Set the complex transmitter model's Power to 50 dBW

complexTrans.Power = 50.0;


//Set the complex transmitter's embedded antenna model to helix

complexTrans.AntennaControl.SetEmbeddedModel("Helix");


//Set the beamwidth of the parablic antenna to 2 degrees

IAgAntennaModelHelix helix = complexTrans.AntennaControl.EmbeddedModel as IAgAntennaModelHelix;

helix.NumberOfTurns = 30.0;


//Orient the complex transmitter embedded antenna's boresight to point directly at the receiver's location

complexTrans.AntennaControl.EmbeddedModelOrientation.AssignAzEl(287.2, 83.4, AgEAzElAboutBoresight.eAzElAboutBoresightRotate);


//Set the receiver to the complex model

facilityReceiver.SetModel("Complex Receiver Model");

IAgReceiverModelComplex complexRcvr = facilityReceiver.Model as IAgReceiverModelComplex;


//Configure the complex receiver to use the antenna object on the same parent facility, by linking

complexRcvr.AntennaControl.ReferenceType = AgEAntennaControlRefType.eAntennaControlRefTypeLink;

complexRcvr.AntennaControl.LinkedAntennaObject = "Antenna/FacilityDish";


//Enable rain loss computation on the receiver

complexRcvr.UseRain = true;

complexRcvr.RainOutagePercent = 0.001;


//Enable the receiver system noise temperature computation.

complexRcvr.SystemNoiseTemperature.ComputeType = AgENoiseTempComputeType.eNoiseTempComputeTypeCalculate;


//Enable the antenna noise temperature computation

complexRcvr.SystemNoiseTemperature.AntennaNoiseTemperature.ComputeType = AgENoiseTempComputeType.eNoiseTempComputeTypeCalculate;

complexRcvr.SystemNoiseTemperature.AntennaNoiseTemperature.UseRain = true;


//Orient the antenna object's boresight to point directly at the transmitter's location

facilityDish.Orientation.AssignAzEl(202.6, 41.2, AgEAzElAboutBoresight.eAzElAboutBoresightRotate);


//Set the antenna object's model to parabolic

facilityDish.SetModel("Parabolic");


//Set the antenan object's design frequency to match the transmitter's 3.2 GHz

facilityDish.Model.DesignFrequency = 3.2;


//Set the antenna object's parabolic model diameter to 5 m.

IAgAntennaModelParabolic parabolic = facilityDish.Model as IAgAntennaModelParabolic;

parabolic.InputType = AgEAntennaModelInputType.eAntennaModelInputTypeDiameter;

parabolic.Diameter = 5.0;


//Create an access object for the access between the transmitter and recevier objects

IAgStkAccess linkAccess = xmtrAsStkObject.GetAccessToObject(rcvrAsStkObject);


//Compute access

linkAccess.ComputeAccess();


// Get the access intervals

IAgIntervalCollection accessIntervals = linkAccess.ComputedAccessIntervalTimes;


// Extract the access intervals and the range information for each access interval

Array dataPrvElements = new object[] { "Time", "Xmtr Gain", "Rcvr Gain", "Eb/No", "BER" };


IAgDataPrvTimeVar dp = linkAccess.DataProviders["Link Information"] as IAgDataPrvTimeVar;


for (int index0 = 0; index0 < accessIntervals.Count; ++index0)

{

    object startTime = null, stopTime = null;


    accessIntervals.GetInterval(index0, out startTime, out stopTime);


    IAgDrResult result = dp.ExecElements(startTime, stopTime, 60, ref dataPrvElements);


    Array timeValues = result.DataSets[0].GetValues();

    Array xmtrGain = result.DataSets[1].GetValues();

    Array rcvrGain = result.DataSets[2].GetValues();

    Array ebno = result.DataSets[3].GetValues();

    Array ber = result.DataSets[4].GetValues();


    for (int index1 = 0; index1 < timeValues.GetLength(0); ++index1)

    {

        string time = (string)timeValues.GetValue(index1);

        double xmtrGainVal = (double)xmtrGain.GetValue(index1);

        double rcvrGainVal = (double)rcvrGain.GetValue(index1);

        double ebnoVal = (double)ebno.GetValue(index1);

        double berVal = (double)ber.GetValue(index1);

        Console.WriteLine("{0}: Xmtr Gain = {1} Rcvr Gain = {2} Eb/No={3} BER={4}", time, xmtrGainVal, rcvrGainVal, ebnoVal, berVal);

    }


    Console.WriteLine();

}

Compute a link budget for a Transmtiter and Receiver pair, using simple models

[C#] Copy Code

// IAgTransmitter geoTransmitter: Transmitter object

// IAgReceiver facilityReceiver: Receiver object


IAgStkObject xmtrAsStkObject = geoTransmitter as IAgStkObject;

IAgStkObject rcvrAsStkObject = facilityReceiver as IAgStkObject;


//Set the transmitter to the simple model

geoTransmitter.SetModel("Simple Transmitter Model");

IAgTransmitterModelSimple simpleTrans = geoTransmitter.Model as IAgTransmitterModelSimple;


//Set the simple transmitter model's frequency to 3.2 GHz

simpleTrans.Frequency = 3.2;


//Set the simple transmitter model's EIRP to 60 dBW

simpleTrans.Eirp = 60.0;


//Set the receiver to the simple model

facilityReceiver.SetModel("Simple Receiver Model");

IAgReceiverModelSimple simpleRcvr = facilityReceiver.Model as IAgReceiverModelSimple;


//Set the simple receiver model's G/T to 60 dB/K

simpleRcvr.GOverT = 60.0;


//Create an access object for the access between the transmitter and recevier objects

IAgStkAccess linkAccess = xmtrAsStkObject.GetAccessToObject(rcvrAsStkObject);


//Compute access

linkAccess.ComputeAccess();


// Get the access intervals

IAgIntervalCollection accessIntervals = linkAccess.ComputedAccessIntervalTimes;


// Extract the access intervals and the range information for each access interval

Array dataPrvElements = new object[] { "Time", "Eb/No", "BER" };


IAgDataPrvTimeVar dp = linkAccess.DataProviders["Link Information"] as IAgDataPrvTimeVar;


for (int index0 = 0; index0 < accessIntervals.Count; ++index0)

{

    object startTime = null, stopTime = null;

    accessIntervals.GetInterval(index0, out startTime, out stopTime);


    IAgDrResult result = dp.ExecElements(startTime, stopTime, 60, ref dataPrvElements);


    Array timeValues = result.DataSets[0].GetValues();

    Array ebno = result.DataSets[1].GetValues();

    Array ber = result.DataSets[2].GetValues();


    for (int index1 = 0; index1 < timeValues.GetLength(0); ++index1)

    {

        string time = (string)timeValues.GetValue(index1);

        double ebnoVal = (double)ebno.GetValue(index1);

        double berVal = (double)ber.GetValue(index1);

        Console.WriteLine("{0}: Eb/No={1} BER={2}", time, ebnoVal, berVal);

    }


    Console.WriteLine();

}

Add a STK Object to constellation using IAgStkObject interface

[C#] Copy Code

// IAgConstellation constellation: Constellation object

// IAgStkObject alos: Satellite Object that is to be added to constellation


// Add object to constellation

constellation.Objects.AddObject(alos);

Add a STK Object to constellation using STK Object Path

[C#] Copy Code

// IAgConstellation constellation: Constellation object


// Add object to constellation

constellation.Objects.Add("Satellite/Cameo");

Compute a coverage definition access

[C#] Copy Code

// IAgCoverageDefinition coverageDefinition: Coverage Definition


// Set AutoRecomputer for Accesses

coverageDefinition.Advanced.AutoRecompute = false;


// Compute

coverageDefinition.ComputeAccesses();


// Export to File

coverageDefinition.ExportAccessesAsText("MyAccess.txt");

coverageDefinition.ReloadAccesses();


// Clear accesses if necessary

//coverageDefinition.ClearAccesses();

Create a coverage definition (on the current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root


// Create the CoverageDefinition

IAgCoverageDefinition cd = root.CurrentScenario.Children.New(AgESTKObjectType.eCoverageDefinition, "cd1") as IAgCoverageDefinition;

Define a coverage definition assets

[C#] Copy Code

// IAgCoverageDefinition coverageDefinition: Coverage definition object


IAgCvAssetListCollection assetCollection = coverageDefinition.AssetList;

string assetName = "Satellite/sat1";

string subAssetName = "Facility/North";


// Remove asset collection if necessary

assetCollection.RemoveAll();


IAgCvAssetListElement satAsset1 = null;


// AvailableAssets returns a one dimensional array of assets

if (Array.IndexOf(assetCollection.AvailableAssets, assetName) != -1)

{

    // Add assets to coverageDefintion

    if (assetCollection.CanAssignAsset(assetName))

    {

        satAsset1 = assetCollection.Add(assetName);


        // Configure asset element

        satAsset1.Required = true;

        satAsset1.Grouping = AgECvAssetGrouping.eGrouped;

    }


    // Add subassets to assets

    if (satAsset1.ContainsSubAssets())

    {

        IAgCvAssetListCollection subAssetCollection = satAsset1.SubAssetList;

        if (subAssetCollection.CanAssignAsset(subAssetName))

        {

            assetCollection.Add(subAssetName);

        }

    }

}

Define a coverage definition by points

[C#] Copy Code

// IAgCoverageDefinition coverageDefinition: Coverage Definition

// String regionFilePath: Path of region file


// Get the IAgCvGrid interface

IAgCvGrid cvGrid = coverageDefinition.Grid;


// Define custom region

cvGrid.BoundsType = AgECvBounds.eBoundsCustomRegions;

IAgCvBoundsCustomRegions oBoundsCustom = cvGrid.Bounds as IAgCvBoundsCustomRegions;

oBoundsCustom.RegionFiles.Add(regionFilePath);

oBoundsCustom.AreaTargets.Add("AreaTarget/AreaTarget1");


// Create an Array of LLA points

// Array should contain Lat, Lon, Alt values

Array points = new object[,]

{

    { 6.9346423789e+01, -5.0260748372e+01, 0.0000000000e+00 },

    { 3.9613371741e+01, -6.6285429903e+01, 0.0000000000e+00 },

    { 3.9880319688e+01, -7.3881767479e+01, 0.0000000000e+00 },

    { 4.0700636942e+01, -1.1224999998e+02, 0.0000000000e+00 }

};


// SetPointsLLA expects a two dimensional array of LLA points

coverageDefinition.PointDefinition.SetPointsLLA(ref points);

Define a custom grid using area targets

[C#] Copy Code

// IAgCoverageDefinition coverageDefinition: Coverage Definition


// Get the IAgCvGrid interface

IAgCvGrid cvGrid = coverageDefinition.Grid;


// Set bound region type to use custom regions

cvGrid.BoundsType = AgECvBounds.eBoundsCustomRegions;


// Get IAgCvBoundsCustomRegions interface

IAgCvBoundsCustomRegions boundRegion = cvGrid.Bounds as IAgCvBoundsCustomRegions;


// Add custom regions

boundRegion.AreaTargets.Add("AreaTarget/AreaTarget1");

boundRegion.AreaTargets.Add("AreaTarget/AreaTarget2");

Define a grid resolution by latitude and longitude

[C#] Copy Code

// IAgCoverageDefinition coverageDefinition: Coverage definition object


// Get the IAgCvGrid interface

IAgCvGrid grid = coverageDefinition.Grid;


// Set resolution type

grid.ResolutionType = AgECvResolution.eResolutionLatLon;


// Get the resolution interface

IAgCvResolution resolution = grid.Resolution;

IAgCvResolutionLatLon latLonResolution = resolution as IAgCvResolutionLatLon;


// Assign LatLon used to define grid resolution

// Uses Angle Dimension

latLonResolution.LatLon = 3.0;

Define and configure grid constraint options

[C#] Copy Code

// IAgCoverageDefinition coverageDefinition: Coverage definition object


IAgCvPointDefinition pointDefinition = coverageDefinition.PointDefinition;


// Set facility as object seed instance

pointDefinition.GridClass = AgECvGridClass.eGridClassFacility;

pointDefinition.UseGridSeed = true;

pointDefinition.SeedInstance = "Facility/North";


// Configure Altitude

pointDefinition.AltitudeMethod = AgECvAltitudeMethod.eAltitude;

pointDefinition.Altitude = 0.0;

coverageDefinition.PointDefinition.GroundAltitudeMethod = AgECvGroundAltitudeMethod.eCvGroundAltitudeMethodUsePointAlt;

Set the coverage analysis time to the asset object time periods.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Root

// IAgCoverageDefinition coverage: An instance of the coverage definition object


string currentDateFormat = stkRoot.UnitPreferences.GetCurrentUnitAbbrv("DateFormat");


// For this example, we will set the coverage analysis time to the times the asset is available.

// Note, this doesn't handle subassets. To do that, you'll just have to iterate through the subasset list.

IAgDate minStartTime = null;

IAgDate maxStartTime = null;


foreach (IAgCvAssetListElement cvAsset in coverage.AssetList)

{

    IAgStkObject subAsset = stkRoot.GetObjectFromPath(cvAsset.ObjectName);

    if (subAsset.Vgt.EventIntervals.Contains("AvailabilityTimeSpan"))

    {

        IAgCrdnEventIntervalResult availableTimeSpan = subAsset.Vgt.EventIntervals["AvailabilityTimeSpan"].FindInterval();

        IAgDate startDate = stkRoot.ConversionUtility.NewDate(currentDateFormat, availableTimeSpan.Interval.Start.ToString());

        if (!(minStartTime != null) || startDate.OLEDate < minStartTime.OLEDate)

        {

            minStartTime = startDate;

        }


        IAgDate stopTime = stkRoot.ConversionUtility.NewDate(currentDateFormat, availableTimeSpan.Interval.Stop.ToString());

        if (!(maxStartTime != null) || stopTime.OLEDate > maxStartTime.OLEDate)

        {

            maxStartTime = stopTime;

        }

    }

}


if (minStartTime != null && maxStartTime != null)

{

    // Now, that we have the minimum start time and the maximum stop time of the asset list, we can explicitly set the coverage analysis time.

    coverage.Interval.AnalysisInterval.SetExplicitInterval(minStartTime.Format(currentDateFormat), maxStartTime.Format(currentDateFormat));

}


Console.WriteLine(

    "Coverage Analysis Interval, StartTime = {0}, StopTime = {1}",

    coverage.Interval.AnalysisInterval.FindStartTime(),

    coverage.Interval.AnalysisInterval.FindStopTime());

Configure a coverage definition adaptive sampling

[C#] Copy Code

// IAgCoverageDefinition coverageDefinition: Coverage definition object


// Get the Sampling interface

IAgCvAdvanced advanced = coverageDefinition.Advanced;

IAgAccessSampling sampling = advanced.Sampling;


// Set the Sampling Method

sampling.SetType(AgESamplingMethod.eSamplingMethodAdaptive);

IAgSamplingMethodAdaptive adaptive = sampling.Strategy as IAgSamplingMethodAdaptive;


// Set properties on the Adaptive sampling method interface

adaptive.MaxTimeStep = 180.0;

adaptive.MinTimeStep = 1.0;

Configure a coverage definition fixed step sampling

[C#] Copy Code

// IAgCoverageDefinition coverageDefinition: Coverage definition object


// Get the Sampling interface

IAgCvAdvanced advanced = coverageDefinition.Advanced;

IAgAccessSampling sampling = advanced.Sampling;


// Set the Sampling Method

sampling.SetType(AgESamplingMethod.eSamplingMethodFixedStep);

IAgSamplingMethodFixedStep fixedStep = sampling.Strategy as IAgSamplingMethodFixedStep;


// Set properties on the Fixed Stop sampling method interface

fixedStep.FixedTimeStep = 360.0;

fixedStep.TimeBound = 5.0;

Configure a coverage definition graphics

[C#] Copy Code

// IAgCvGraphics cvGraphics: Coverage definition


// Configure animation

IAgCvGfxAnimation cvAnimation = cvGraphics.Animation;

cvAnimation.IsSatisfactionVisible = true;

cvAnimation.Color = Color.Green;


// Configure progress

IAgCvGfxProgress cvProgress = cvGraphics.Progress;

cvProgress.IsVisible = true;

cvProgress.Color = Color.Red;


// Configure static

IAgCvGfxStatic cvStatic = cvGraphics.Static;

cvStatic.Color = Color.Blue;

cvStatic.MarkerStyle = "Star";

Create a facility (on current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create a facility on current scenario central body

IAgFacility facility = root.CurrentScenario.Children.New(AgESTKObjectType.eFacility, "MyFacility") as IAgFacility;

Create a facility from facility database

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Get STK database location using Connect

IAgExecCmdResult result = root.ExecuteCommand("GetDirectory / Database Facility");

string facDataDir = result[0];

string filelocation = Path.Combine(facDataDir, @"stkFacility.fd");


// Import object from database using Connect

string command = "ImportFromDB * Facility \"" + filelocation + "\" Class Facility SiteName Weilheim";

root.ExecuteCommand(command);


IAgFacility facility = root.GetObjectFromPath("Facility/Weilheim") as IAgFacility;

Create a facility on Earth at lat/lon/alt

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgFacility facility = root.CurrentScenario.Children.NewOnCentralBody(AgESTKObjectType.eFacility, "MyFacility", "Earth") as IAgFacility;


// Assuming unit preferences are set to radians for latitude and longitude and km for distance

facility.Position.AssignPlanetodetic(0.4506, -1.4011, 4);

Create a facility on specified central body at lat/lon/alt

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgFacility facObject = root.CurrentScenario.Children.NewOnCentralBody(AgESTKObjectType.eFacility, "Facility1", "Mars") as IAgFacility;


// Assuming unit preferences are set to radians for latitude and longitude and km for distance

facObject.Position.AssignPlanetodetic(-5.4245, 0.1902, 0);

Move a facility while use terrain option is set true

[C#] Copy Code

// IAgFacility fac: Facility object


// Set altitude automatically by using terrain data

fac.UseTerrain = true;


// Set the position ignores the altitude value in AssignGeodetic

fac.Position.AssignGeodetic(29.98, -90.25, 9);


// Ignores the altitude value in AssignGeocentric

fac.Position.AssignGeocentric(32.12, -110.93, 787);


// Ignores the radius value in AssignSpherical

fac.Position.AssignSpherical(40.65, -73.78, 7);

Configure access duration figure of merit

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


// Set figure of merit defintion to eFmAccessDuration

fom.SetDefinitionType(AgEFmDefinitionType.eFmAccessDuration);


// Get IAgFmDefCompute interface

IAgFmDefCompute defComp = fom.Definition as IAgFmDefCompute;


if (defComp.IsComputeTypeSupported(AgEFmCompute.ePercentAbove))

{

    // Set Compute type to supported compute option

    defComp.SetComputeType(AgEFmCompute.ePercentAbove);


    // Get compute option compute interface

    IAgFmDefDataPercentLevel fomData = defComp.Compute as IAgFmDefDataPercentLevel;

    fomData.PercentLevel = .25;

}

Configure coverage time figure of merit

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


// Set figure of merit defintion to eFmCoverageTime

fom.SetDefinitionType(AgEFmDefinitionType.eFmCoverageTime);


// Get IAgFmDefCompute interface

IAgFmDefCompute defComp = fom.Definition as IAgFmDefCompute;


if (defComp.IsComputeTypeSupported(AgEFmCompute.eTotalTimeAbove))

{

    // Set Compute type to supported compute option

    defComp.SetComputeType(AgEFmCompute.eTotalTimeAbove);


    // Get compute option compute interface

    IAgFmDefDataMinAssets fomData = defComp.Compute as IAgFmDefDataMinAssets;

    fomData.MinAssets = 15;

}

Configure figure of merit Age Of Data definition

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


// Get the IAgFmDefAgeOfData interface

fom.SetDefinitionType(AgEFmDefinitionType.eFmAgeOfData);

IAgFmDefAgeOfData ageOfData = fom.Definition as IAgFmDefAgeOfData;


// Set the minimum number of assets for computing

ageOfData.MinAssets = 2;

Configure figure of merit contours

[C#] Copy Code

// IAgFmGfxContours contours: Figure of Merit properties


contours.IsVisible = true;

contours.ContourType = AgEFmGfxContourType.eSmoothFill;

contours.ColorMethod = AgEFmGfxColorMethod.eExplicit;


// Add level ranges (batch)

contours.LevelAttributes.AddLevelRange(25, 35, 1);

IAgFmGfxLevelAttributesElement firstLevel = contours.LevelAttributes[0];

firstLevel.Color = Color.Blue;


// Add one level (individually)

IAgFmGfxLevelAttributesElement level = contours.LevelAttributes.AddLevel(55);

level.Color = Color.Red;

Configure figure of merit definition altitude access constraint

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


// Set access constraint defintion to altitude

fom.SetAccessConstraintDefinition(AgEFmConstraintName.eFmAltitude);


// Get IAgFmDefAccessConstraint interface

IAgFmDefAccessConstraint defAccessCnstr = fom.Definition as IAgFmDefAccessConstraint;


// Confiure access constraint properties

defAccessCnstr.SetComputeType(AgEFmCompute.eMaximum);

defAccessCnstr.AcrossAssets = AgEFmAcrossAssets.eFmMinimum;

defAccessCnstr.TimeStep = 60.0;

Configure figure of merit Scalar Calculation definition

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


// Set the Scalar Calculation definition.

IAgFmDefScalarCalculation scalarCalculation = fom.SetScalarCalculationDefinition("CentralBody/Earth ElapsedTimeFromStart");

Configure figure of merit Scalar Calculation definition using VGT

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties

// IAgStkObjectRoot stkRoot: STK Object Model root


// Get the qualified path of a Scalar Calculation (e.g.

IAgCrdnProvider provider = stkRoot.VgtRoot.GetProvider("CentralBody/Sun");

IAgCrdnCalcScalar calcScalar = provider.CalcScalars[0];

string calcScalarQualifiedPath = (calcScalar as IAgCrdn).QualifiedPath;


// Set the Scalar Calculation definition using the qualified path

IAgFmDefScalarCalculation scalarCalculation = fom.SetScalarCalculationDefinition(calcScalarQualifiedPath);

Configure figure of merit System Response Time

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


fom.SetDefinitionType(AgEFmDefinitionType.eFmSystemResponseTime);

IAgFmDefSystemResponseTime systemResponseTime = fom.Definition as IAgFmDefSystemResponseTime;


systemResponseTime.CommandStationPath = @"/Application/STK/Scenario/CodeSnippetScenario/Facility/Facility1";

Configure figure of merit System Response Time reset

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


fom.SetDefinitionType(AgEFmDefinitionType.eFmSystemResponseTime);

IAgFmDefSystemResponseTime systemResponseTime = fom.Definition as IAgFmDefSystemResponseTime;


systemResponseTime.CommandStationPath = "NONE";

Create a figure of merit on a coverage definition

[C#] Copy Code

// IAgCoverageDefinition covdef: Coverage Definition object


// Get the coverage definition as a IAgStkObject interface

IAgStkObject covdefObject = covdef as IAgStkObject;


// Create the figure of merit

IAgFigureOfMerit fom = covdefObject.Children.New(AgESTKObjectType.eFigureOfMerit, "MyFigureOfMerit") as IAgFigureOfMerit;

Inspect grid by selecting a point

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


IAgFmGridInspector gridInspector = fom.GridInspector;

gridInspector.SelectPoint(-13.864, -51.088);


IAgDataPrvTimeVar pointFom = gridInspector.PointFOM as IAgDataPrvTimeVar;

IAgDrResult pointFomResult = pointFom.ExecSingle("1 Jan 2012 12:00:00.00");


IAgDataPrvInterval pointSatisfaction = gridInspector.PointSatisfaction as IAgDataPrvInterval;

IAgDrResult pointSatisfactionResult = pointSatisfaction.Exec("1 Jan 2012 12:00:00.00", "2 Jan 2012 12:00:00.00");


IAgDataPrvTimeVar regionFom = gridInspector.RegionFOM as IAgDataPrvTimeVar;

IAgDrResult regionFomResult = regionFom.ExecSingle("1 Jan 2012 12:00:00.00");


IAgDataPrvInterval regionSatisfaction = gridInspector.RegionSatisfaction as IAgDataPrvInterval;

IAgDrResult regionSatisfactionResult = regionSatisfaction.Exec("1 Jan 2012 12:00:00.00", "2 Jan 2012 12:00:00.00");

Set the figure of merit definition to access constraint by enumeration

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


IAgFmDefAccessConstraint acd = fom.SetAccessConstraintDefinition(AgEFmConstraintName.eFmAzimuthRate);

Set the figure of merit definition to access constraint by name

[C#] Copy Code

// IAgFigureOfMerit fom: Figure of Merit properties


IAgFmDefAccessConstraint defAccessCnstr = fom.SetAccessConstraintDefinitionName("AzimuthRate");


// Confiure access constraint properties

defAccessCnstr.SetComputeType(AgEFmCompute.eMaximum);

defAccessCnstr.AcrossAssets = AgEFmAcrossAssets.eFmMinimum;

defAccessCnstr.TimeStep = 60.0;

Add MTO track

[C#] Copy Code

// IAgMto mto: MTO object


IAgMtoTrackCollection trackCollection = mto.Tracks;


Array time = new object[]

             {

                 "1 Jan 2012 12:10:00.000", "1 Jan 2012 12:20:00.000"

             };

Array latitude = new object[]

                 {

                     27.97, -26.51

                 };

Array longitude = new object[]

                  {

                      -80.01, 119.42

                  };

Array altitude = new object[]

                 {

                     20.1, 44.2

                 };


// AddTrack expects each safe array parameter to be two dimensional,

// all arrays must have the same length

IAgMtoTrack track = trackCollection.AddTrack(1, ref time, ref latitude, ref longitude, ref altitude);

Configure MTO

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgMto mto: Mto Object


IAgScenario scenario = root.CurrentScenario as IAgScenario;

scenario.SetTimePeriod("1 Feb 2008 12:00:00.000", "2 Feb 2008 12:00:00.000");


// Number of tracks and points to add

double trackCount = 10;

double pointCount = 20;


// Initial values from which we will interpolate

double lat0 = 40.04;

double lon0 = -75.595;

double alt0 = 0;


root.BeginUpdate(); // Call BeginUpdate for STK engine to delay updates


for (int i = 0; i < trackCount; ++i)

{

    IAgMtoTrack track = mto.Tracks.Add(i);

    IAgDate date = root.ConversionUtility.NewDate("UTCG", scenario.StartTime as string);


    // Interpolate mto points

    for (int j = 0; j < pointCount; ++j)

    {

        double lat = lat0 + 1 * i;

        double lon = lon0 + 0.1 * j;

        double alt = alt0;


        date = date.Add("sec", 120);


        track.Points.AddPoint(date.Format("UTCG"), lat, lon, alt);

    }

}


root.EndUpdate();

Create a MTO (on current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create the MTO

IAgMto mto = root.CurrentScenario.Children.New(AgESTKObjectType.eMTO,  "mto1") as IAgMto;

Extend MTO track

[C#] Copy Code

// IAgMtoTrackPointCollection trackPointCollection: Track point collection


Array time = new object[]

             {

                 "1 Jan 2012 12:20:00.000", "1 Jan 2012 12:30:00.000"

             };

Array latitude = new object[]

                 {

                     -18.35, 19.55

                 };

Array longitude = new object[]

                  {

                      -42.10, 83.21

                  };

Array altitude = new object[]

                 {

                     30.52, 15.81

                 };


// Extend expects each parameter to be a two dimensional array,

// all arrays must have the same length

trackPointCollection.Extend(ref time, ref latitude, ref longitude, ref altitude);

Load MTO track points from file

[C#] Copy Code

// IAgMtoTrack track: MTO track object

// String filePath: Path of ephemeris file


// LoadPoints expects the path an Ephemeris file path

track.Points.LoadPoints(filePath);

Remove MTO track

[C#] Copy Code

// IAgMto mto: MTO object


IAgMtoTrackCollection trackCollection = mto.Tracks;


// Build tracksToRemove Array

Array tracksToRemove = new object[]

                       {

                           trackCollection[0], trackCollection[1]

                       };


// RemoveTracks expects a one dimensional array of IAgMtoTrack objects

trackCollection.RemoveTracks(ref tracksToRemove);

Remove MTO tracks by ids

[C#] Copy Code

// IAgMto mto: MTO object


IAgMtoTrackCollection trackCollection = mto.Tracks;


// RemoveTracksById expects a one dimensional array of mto track ids

Array tracks = new object[]

               {

                   1, 4

               };

trackCollection.RemoveTracksById(ref tracks);

Compute MTO field of view

[C#] Copy Code

// IAgMto mto: MTO object


IAgMtoAnalysisFieldOfView fov = mto.Analysis.FieldOfView;


// AreTracksInFOV expects a one dimensional array of mto track ids

Array tracks = new object[]

               {

                   1, 4

               };


bool tracksInView = fov.AreTracksInFOV(AgEMtoTrackEval.eMtoTrackEvalAny, ref tracks, "1 Jan 2012 12:00:00.000");

Compute MTO ranges

[C#] Copy Code

// IAgMto mto: MTO object


IAgMtoAnalysisRange range = mto.Analysis.Range;

range.StkObjectPath = "Satellite/J2Satellite";


// ComputeRanges expects a one dimensional array of mto track ids

// ComputeRanges returns a two dimensional array of track id, visibility, and range

Array tracks = new object[]

               {

                   1, 4

               };


Array result = range.ComputeRanges(AgEMtoRangeMode.eMtoRangeModeEach, ref tracks, "1 Jan 2012 12:00:00.000");


// Print results

for (int i = 0; i < result.GetLength(0); i++)

{

    Console.WriteLine("Track #: {0}, Visible: {1}, Range: {2}", result.GetValue(i, 0), result.GetValue(i, 1), result.GetValue(i, 2));

}

Compute visibility with MTO tracks

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgMto mto: MTO object to use for visibility analysis


// Are all the tracks visible from the other STK Object at the specified time?


IAgMtoAnalysisVisibility mtoVisibility = mto.Analysis.Visibility;

mtoVisibility.UseTerrain = false; // Set to true to use terrain instead of line of sight.

mtoVisibility.Entirety = AgEMtoEntirety.eMtoEntiretyPartial; // Only applies if MTO is static (i.e. non time dependent).


mtoVisibility.StkObjectPath = "Satellite/J2Satellite";

bool allTracksAreVisible = mtoVisibility.AreAllTracksVisible("1 Jan 2012 14:02:00.000");

Determine if all the specified tracks (i.e. a subset of the MTO tracks) are visible from the other STK Object at the specified time?

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgMto mto: MTO object to use for visibility analysis


IAgMtoAnalysisVisibility mtoVisibility = mto.Analysis.Visibility;

mtoVisibility.UseTerrain = false; // Set to true to use terrain instead of line of sight.

mtoVisibility.Entirety = AgEMtoEntirety.eMtoEntiretyPartial; // Only applies if MTO is static (i.e. non time dependent).


mtoVisibility.StkObjectPath = "Satellite/J2Satellite";


Array tracksOfInterest = new object[]

                         {

                             1, 2, 7

                         };


// AreTracksVisible expects as the second parameter a one dimensional array of mto track ids

bool areTracksAreVisible = mtoVisibility.AreTracksVisible(AgEMtoTrackEval.eMtoTrackEvalAll, ref tracksOfInterest, "1 Jan 2012 12:02:00.000");

Determine if any track is visible from other STK Object at the specified time

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgMto mto: MTO object to use for visibility analysis


IAgMtoAnalysisVisibility mtoVisibility = mto.Analysis.Visibility;

mtoVisibility.UseTerrain = false; // Set to true to use terrain instead of line of sight.

mtoVisibility.Entirety = AgEMtoEntirety.eMtoEntiretyPartial; // Only applies if MTO is static (i.e. non time dependent).


mtoVisibility.StkObjectPath = "Satellite/J2Satellite";

bool anyTrackIsVisible = mtoVisibility.IsAnyTrackVisible("1 Jan 2012 14:02:00.000");

Determine which tracks are visible from the other STK Object at the specified time

[C#] Copy Code

// IAgMto mto: MTO object to use for visibility analysis


IAgMtoAnalysisVisibility mtoVisibility = mto.Analysis.Visibility;

mtoVisibility.UseTerrain = false; // Set to true to use terrain instead of line of sight.

mtoVisibility.Entirety = AgEMtoEntirety.eMtoEntiretyPartial; // Only applies if MTO is static (i.e. non time dependent).


mtoVisibility.StkObjectPath = "Satellite/J2Satellite";


// ComputeAllTracks returns a two dimensional array whose elements are trackid and visibility

Array trackVisibilityArray = mtoVisibility.ComputeAllTracks(AgEMtoVisibilityMode.eVisibilityModeEach, "1 Jan 2008 12:00:00.000");


// Ouput results

Console.WriteLine("ComputeAllTracks:");

for (int i = 0; i < trackVisibilityArray.GetLength(0); ++i)

{

    Console.WriteLine("   Track {0} visibility: {1}",

        Convert.ToInt32(trackVisibilityArray.GetValue(i, 0)),

        Convert.ToInt32(trackVisibilityArray.GetValue(i, 1)));

}

Which tracks of the specified subset of tracks are visible from the other STK Object at the specified time?

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgMto mto: MTO object to use for visibility analysis


IAgMtoAnalysisVisibility mtoVisibility = mto.Analysis.Visibility;

mtoVisibility.UseTerrain = false; // Set to true to use terrain instead of line of sight.

mtoVisibility.Entirety = AgEMtoEntirety.eMtoEntiretyPartial; // Only applies if MTO is static (i.e. non time dependent).


Array tracksOfInterest = new object[]

                         {

                             1, 2, 7

                         };


mtoVisibility.StkObjectPath = "Satellite/J2Satellite";


// ComputeTracks expects as the second parameter a one dimensional array of mto track ids

// ComputeTracks returns a two dimensional array whose values are track id and visiblity

Array trackVisibilityArray = mtoVisibility.ComputeTracks(AgEMtoVisibilityMode.eVisibilityModeEach, ref tracksOfInterest, "1 Jan 2012 12:05:00.000");


// Output results

Console.WriteLine("ComputeTracks:");

for (int i = 0; i < trackVisibilityArray.GetLength(0); ++i)

{

    Console.WriteLine("   Track {0} visibility: {1}",

        Convert.ToInt32(trackVisibilityArray.GetValue(i, 0)),

        Convert.ToInt32(trackVisibilityArray.GetValue(i, 1)));

}

Configure MTO graphics

[C#] Copy Code

// IAgMto mto: Mto object


IAgMtoVOTrackCollection tracks = mto.VO.Tracks;

foreach (IAgMtoVOTrack element in tracks)

{

    element.Marker.PixelSize = 12;

    element.Marker.OrientationMode = AgEVOMarkerOrientation.eVOMarkerOrientationAngle;

    element.Marker.XOrigin = AgEVOMarkerOriginType.eRight;

    element.Marker.YOrigin = AgEVOMarkerOriginType.eBottom;

    element.Marker.Angle = 1.23;


    element.Marker.MarkerType = AgEMarkerType.eImageFile;

    element.Marker.SetMarkerImageFile(@"STKData\VO\Markers\Fire.ppm");


    element.Model.IsVisible = true;

    element.Model.Filename = @"STKData\VO\Models\Land\ariane-lp.mdl";

    element.Model.InitialBearing = 3.0;

    element.Model.ScaleValue = 2.0;

    element.Model.ZPointsNadir = true;


    element.Label.Enable = true;

    element.Label.X = 33.5;

    element.Label.Y = 82.2;

    element.Label.Z = 100.0;

    element.Label.OffsetFrame = AgEOffsetFrameType.eOffsetFrameCartesian;

}

Configure MTO track marker

[C#] Copy Code

// IAgMtoVOTrack track: Mto VO track properties


IAgMtoVOMarker marker = track.Marker;

marker.PixelSize = 12;

marker.OrientationMode = AgEVOMarkerOrientation.eVOMarkerOrientationAngle;

marker.XOrigin = AgEVOMarkerOriginType.eRight;

marker.YOrigin = AgEVOMarkerOriginType.eBottom;

marker.Angle = 1.23;

marker.MarkerType = AgEMarkerType.eImageFile;

marker.SetMarkerImageFile(@"STKData\VO\Markers\Fire.ppm");

Configure MTO track model

[C#] Copy Code

// IAgMtoVOTrack track: Mto VO track properties


IAgMtoVOModel model = track.Model;

model.IsVisible = true;

model.Filename = @"STKData\VO\Models\Land\ariane-lp.mdl";

model.InitialBearing = 3.0;

model.ScaleValue = 2.0;

model.ZPointsNadir = true;

Create a place (on current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create a place on current scenario central body

IAgPlace place = root.CurrentScenario.Children.New(AgESTKObjectType.ePlace, "MyPlace") as IAgPlace;

Create a place from facility database

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Get STK database location using Connect

IAgExecCmdResult result = root.ExecuteCommand("GetDirectory / Database Facility");

string facDataDir = result[0];

string filelocation = Path.Combine(facDataDir, "stkFacility.fd");


// Import object from database using Connect

string command = "ImportFromDB * Facility \"" + filelocation + "\" Class Place SiteName Weilheim";

root.ExecuteCommand(command);


IAgPlace place = root.GetObjectFromPath("Place/Weilheim") as IAgPlace;

Create a place on Earth at lat/lon/alt

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgPlace place = root.CurrentScenario.Children.NewOnCentralBody(AgESTKObjectType.ePlace, "MyPlace", "Earth") as IAgPlace;


// Assuming unit preferences are set to radians for latitude and longitude and km for distance

place.Position.AssignPlanetodetic(0.4506, -1.4011, 4);

Create a place on specified central body at lat/lon/alt

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgPlace placeObject = root.CurrentScenario.Children.NewOnCentralBody(AgESTKObjectType.ePlace, "Place1", "Mars") as IAgPlace;


// Assuming unit preferences are set to radians for latitude and longitude and km for distance

placeObject.Position.AssignPlanetodetic(-5.4245, 0.1902, 0);

Move a place while use terrain option is set true

[C#] Copy Code

// IAgPlace place: Place object


// Set altitude automatically by using terrain data

place.UseTerrain = true;


// Set the position ignores the altitude value in AssignGeodetic

place.Position.AssignGeodetic(29.98, -90.25, 9);


// Ignores the altitude value in AssignGeocentric

place.Position.AssignGeocentric(32.12, -110.93, 787);


// Ignores the radius value in AssignSpherical

place.Position.AssignSpherical(40.65, -73.78, 7);

Configure a planet

[C#] Copy Code

// IAgPlanet planet: Planet


planet.PositionSource = AgEPlPositionSourceType.ePosCentralBody;


// Get IAgPlPosCentralBody interface

IAgPlPosCentralBody body = planet.PositionSourceData as IAgPlPosCentralBody;


body.AutoRename = false;

body.CentralBody = "Jupiter";


// AvailableEphemSourceTypes is a one dimensional array of AgEEphemSourceType values

if (Array.IndexOf(body.AvailableEphemSourceTypes, (int)AgEEphemSourceType.eEphemAnalytic) != -1)

{

    body.EphemSource = AgEEphemSourceType.eEphemAnalytic;

}

Configure a planet position by ephemeris source file(using common tasks)

[C#] Copy Code

// IAgPlanet planet: Planet

// String planetEphemeris: Planet Ephemeris file


// Position source files traditionally have .pe extensions

planet.CommonTasks.SetPositionSourceFile(planetEphemeris);

Configure a planet graphics

[C#] Copy Code

// IAgPlGraphics graphics: Planet graphics


graphics.Inherit = false;


graphics.Color = Color.Red;

graphics.MarkerStyle = "Circle";

graphics.LineStyle = AgELineStyle.eMDashDot;

graphics.LineWidth = AgELineWidth.e4;


graphics.InertialPositionVisible = false;

graphics.SubPlanetPointVisible = false;

graphics.PositionLabelVisible = false;

graphics.SubPlanetLabelVisible = false;

graphics.OrbitVisible = true;

graphics.OrbitDisplay = AgEPlOrbitDisplayType.eOrbitDisplayTime;

IAgPlOrbitDisplayTime displayTime = graphics.OrbitDisplayData as IAgPlOrbitDisplayTime;

displayTime.Time = 10000.00;

Compute the probability of detection of a target for a monostatic search/track radar

[C#] Copy Code

// IAgRadar radar: Radar object

// IAgAircraft targetAircraft: Aircraft object

// IAgRFEnvironment scenarioRFEnv: Scenario RF Environment


IAgStkObject rdrAsStkObject = radar as IAgStkObject;

IAgStkObject tgtAsStkObject = targetAircraft as IAgStkObject;


//Enable the rain loss computation on the scenario RF environment

scenarioRFEnv.PropagationChannel.EnableRainLoss = true;


//Configure the radar object as a monostatic model.

radar.SetModel("Monostatic");

IAgRadarModelMonostatic monostaticModel = radar.Model as IAgRadarModelMonostatic;


//Orient the radar antenna in the direction of the target

radar.Model.AntennaControl.EmbeddedModelOrientation.AssignAzEl(50.9, 36.8, AgEAzElAboutBoresight.eAzElAboutBoresightRotate);


//Set the radar antenna model to parabolic

radar.Model.AntennaControl.SetEmbeddedModel("Parabolic");

IAgAntennaModelParabolic parabolic = radar.Model.AntennaControl.EmbeddedModel as IAgAntennaModelParabolic;


//Give the parabolic antenna a 2 deg beamwidth;

parabolic.InputType = AgEAntennaModelInputType.eAntennaModelInputTypeBeamwidth;

parabolic.Beamwidth = 2.0;


//Put the monostatic radar model in Search/Track mode

monostaticModel.SetMode("Search Track");

IAgRadarModeMonostaticSearchTrack searchTrackMode = monostaticModel.Mode as IAgRadarModeMonostaticSearchTrack;


//Set the waveform type to fixed prf

searchTrackMode.SetWaveformType(AgERadarWaveformSearchTrackType.eRadarWaveformSearchTrackTypeFixedPRF);

IAgRadarWaveformMonostaticSearchTrackFixedPRF fixedPrf = searchTrackMode.Waveform as IAgRadarWaveformMonostaticSearchTrackFixedPRF;

fixedPrf.PulseDefinition.Prf = 0.002; //2 kHz


//Set the pulse width to 1e-8 sec

fixedPrf.PulseDefinition.PulseWidth = 1.0e-8; //sec


//Set the number of pulses

fixedPrf.PulseDefinition.NumberOfPulses = 25;


//Set the pulse integration strategy to goal SNR

fixedPrf.PulseIntegrationType = AgERadarPulseIntegrationType.eRadarPulseIntegrationTypeGoalSNR;

IAgRadarPulseIntegrationGoalSNR pulseIntGoalSNR = fixedPrf.PulseIntegration as IAgRadarPulseIntegrationGoalSNR;

pulseIntGoalSNR.SNR = 40.0; //dB


//Set the transmit frequency

monostaticModel.Transmitter.FrequencySpecification = AgERadarFrequencySpec.eRadarFrequencySpecFrequency;

monostaticModel.Transmitter.Frequency = 2.1; //GHz


//Set the transmit power

monostaticModel.Transmitter.Power = 50.0; //dBW


//Enable rain loss computation on the receiver

monostaticModel.Receiver.UseRain = true;

monostaticModel.Receiver.RainOutagePercent = 0.001;


//Enable the receiver system noise temperature computation.

monostaticModel.Receiver.SystemNoiseTemperature.ComputeType = AgENoiseTempComputeType.eNoiseTempComputeTypeCalculate;


//Enable the antenna noise temperature computation

monostaticModel.Receiver.SystemNoiseTemperature.AntennaNoiseTemperature.ComputeType = AgENoiseTempComputeType.eNoiseTempComputeTypeCalculate;

monostaticModel.Receiver.SystemNoiseTemperature.AntennaNoiseTemperature.UseRain = true;


//Don't inherit the radar cross section settings from the scenario

targetAircraft.RadarCrossSection.Inherit = false;

IAgRadarCrossSectionModel rcs = targetAircraft.RadarCrossSection.Model as IAgRadarCrossSectionModel;


//Set the radar cross section compute strategy to constan value

rcs.FrequencyBands[0].SetComputeStrategy("Constant Value");

IAgRadarCrossSectionComputeStrategyConstantValue constValRcs =

    rcs.FrequencyBands[0].ComputeStrategy as IAgRadarCrossSectionComputeStrategyConstantValue;


//Set the constant radar cross section to 0.5 dBsm

constValRcs.ConstantValue = 0.5; //dBsm


//Create an access object for the access between the radar and target

IAgStkAccess radarAccess = rdrAsStkObject.GetAccessToObject(tgtAsStkObject);


//Compute access

radarAccess.ComputeAccess();


// Get the access intervals

IAgIntervalCollection accessIntervals = radarAccess.ComputedAccessIntervalTimes;


// Extract the access intervals and the range information for each access interval

Array dataPrvElements = new object[] { "Time", "S/T SNR1", "S/T PDet1", "S/T Integrated SNR", "S/T Integrated PDet" };


IAgDataPrvTimeVar dp = radarAccess.DataProviders["Radar SearchTrack"] as IAgDataPrvTimeVar;


for (int index0 = 0; index0 < accessIntervals.Count; ++index0)

{

    object startTime = null, stopTime = null;

    accessIntervals.GetInterval(index0, out startTime, out stopTime);


    IAgDrResult result = dp.ExecElements(startTime, stopTime, 60, ref dataPrvElements);


    Array timeValues = result.DataSets.GetDataSetByName("Time").GetValues();

    Array snr1 = result.DataSets.GetDataSetByName("S/T SNR1").GetValues();

    Array pdet1 = result.DataSets.GetDataSetByName("S/T PDet1").GetValues();

    Array integSnr = result.DataSets.GetDataSetByName("S/T Integrated SNR").GetValues();

    Array integPdet = result.DataSets.GetDataSetByName("S/T Integrated PDet").GetValues();


    for (int index1 = 0; index1 < timeValues.GetLength(0); ++index1)

    {

        string time = (string)timeValues.GetValue(index1);

        double snr1Val = (double)snr1.GetValue(index1);

        double pdet1Val = (double)pdet1.GetValue(index1);

        double integSnrVal = (double)integSnr.GetValue(index1);

        double integPdetVal = (double)integPdet.GetValue(index1);

        Console.WriteLine("{0}: SNR1={1} PDet1={2} Integrated SNR={3} Integrated PDet={4}", time, snr1Val, pdet1Val, integSnrVal, integPdetVal);

    }


    Console.WriteLine();

}

Add analytical terrain to the scenario on Earth central body

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// String terrainFile: Path of Terrain data file


// Retrieve the IAgScenario interface

IAgScenario scenario = root.CurrentScenario as IAgScenario;


IAgCentralBodyTerrainCollection terrainCollection = scenario.Terrain;

IAgTerrainCollection elementCollection = terrainCollection["Earth"].TerrainCollection;


// Add terrain data file to current scenario's terrain collection

// Terrain data files traditionally have .dte extensions

IAgTerrain terrain = elementCollection.Add(terrainFile, AgETerrainFileType.eMUSERasterFile);


// Set Scenario to use terrain data file

terrain.UseTerrain = true;

Configure scenario animation

[C#] Copy Code

// IAgScenario scenario: Scenario


IAgScAnimation animation = scenario.Animation;


animation.StartTime = "1 Jun 2004 12:00:00.00";

animation.EnableAnimCycleTime = true;

animation.AnimCycleType = AgEScEndLoopType.eEndTime;

animation.AnimCycleTime = "2 Jun 2004 12:00:00.00";

animation.AnimStepValue = 1000;

animation.RefreshDeltaType = AgEScRefreshDeltaType.eRefreshDelta;

animation.RefreshDelta = 0.02;

Configure scenario text font

[C#] Copy Code

// IAgScenario scenario: Scenario


IAgSc3dFont fonts = scenario.VO.LargeFont;


fonts.Bold = true;

fonts.Italic = true;

fonts.PtSize = AgESc3dPtSize.eSc3dFontSize36;


if (fonts.IsFontAvailable("Impact"))

{

    fonts.Name = "Impact";

}


// AvailableFonts returns a one dimensional array of font strings

Array allFonts = fonts.AvailableFonts;

int index = Array.IndexOf(allFonts, "Courier");

if (index != -1)

{

    fonts.Name = allFonts.GetValue(index) as string;

}

Add a new STK Object to the scenario

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


root.CurrentScenario.Children.New(AgESTKObjectType.eShip, "Ship1");

Import an existing STK Object file into the scenario

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// String stkObjectLocation: Path of STK Object external file


root.CurrentScenario.Children.ImportObject(stkObjectLocation);

Retrieve the list of scenario's children of a given type

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// AgESTKObjectType type: Object type in scenario that we want to list


IAgStkObjectElementCollection allChildrenOfType = root.CurrentScenario.Children.GetElements(type);


foreach (IAgStkObject o in allChildrenOfType)

{

    Console.WriteLine(o.InstanceName);

}

Close a scenario

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


root.CloseScenario();

Create a new scenario (closing the current scenario if necessary)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Close current scenario

if (root.CurrentScenario != null)

{

    root.CloseScenario();

}

root.NewScenario("Scenario1");


// Get IAgScenario interface

IAgScenario scenario = root.CurrentScenario as IAgScenario;


// Set scenario start and stop times

scenario.SetTimePeriod("1 Jun 1999 12:00:00.00", "2 Jun 1999 12:00:00.00");

Load a scenario (closing the current scenario if necessary)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// String scenarioLocation: Specified path of scenario


// close current scenario

if (root.CurrentScenario != null)

{

    root.CloseScenario();

}

root.LoadScenario(scenarioLocation);

Save a scenario

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


root.SaveScenario();

Save a scenario to a new location (Save as)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// String fileName: Specified path and file name of scenario


root.SaveScenarioAs(fileName);

Define a complex sensor

[C#] Copy Code

// IAgSensor sensor: Sensor object


IAgSnComplexConicPattern patterndata = sensor.CommonTasks.SetPatternComplexConic(10.0, 70.0, 20.0, 220.0);

patterndata.AngularResolution = 0.5;

Define a custom sensor

[C#] Copy Code

// IAgSensor sensor: Sensor object

// String sensorPatternPath: Path of Custom Sensor data file


// Set pattern type to Custom

IAgSnCustomPattern customPattern = sensor.CommonTasks.SetPatternCustom(sensorPatternPath);

customPattern.AngularResolution = 6.0;

customPattern.UseNativeResolution = false;

Define a half power sensor

[C#] Copy Code

// IAgSensor sensor: Sensor object


// Configure pattern

IAgSnHalfPowerPattern pattern = sensor.CommonTasks.SetPatternHalfPower(12.5, 3.4, 6.0);

Define a SAR sensor

[C#] Copy Code

// IAgSensor sensor: Sensor object


// Configure pattern

IAgSnSARPattern patterndata = sensor.CommonTasks.SetPatternSAR(10.0, 60.0, 40.0, 30.0, 700.0);

Define a simple conic sensor

[C#] Copy Code

// IAgSensor sensor: Sensor object


IAgSnSimpleConicPattern patternData = sensor.CommonTasks.SetPatternSimpleConic(40.0, 0.1);

Define and compute sensor swath

[C#] Copy Code

// IAgSensor sensor: Sensor object


// Configure swath display properties

IAgSwath swath = sensor.Swath;

swath.Enable = true;

swath.Color = Color.Red; // red

swath.LineStyle = AgELineStyle.eLMSDash;

swath.LineWidth = AgELineWidth.e2;


// New swath properties

swath.UseMaximumCone = true;

swath.CurvatureTolerance = 90.0;

swath.ScatteringTolerance = 70.0;

swath.MinimumStep = 5;

swath.MaximumStep = 10;


swath.AddTimeInterval("1 Jan 2012 12:00:00.000", "1 Jan 2012 13:00:00.000");

swath.AddTimeInterval("1 Jan 2012 14:00:00.000", "1 Jan 2012 15:00:00.000");

Define external sensor pointing

[C#] Copy Code

// IAgSensor sensor: Sensor object

// String externalSensorPointingPath: Path of sensor external file


// Sensor pointing data files traditionally have .sp extensions

sensor.SetPointingExternalFile(externalSensorPointingPath);


IAgSnPtExternal external = sensor.Pointing as IAgSnPtExternal;

Define fixed location

[C#] Copy Code

// IAgSensor sensor: Sensor object


// Set sensor's location to fixed

sensor.SetLocationType(AgESnLocation.eSnFixed);


// Configure sensor location

IAgPosition pos = sensor.LocationData as IAgPosition;

pos.AssignCartesian(595.20, -110.12, 4.6);

Define fixed sensor pointing

[C#] Copy Code

// IAgSensor sensor: Sensor object


IAgSnPtFixed fixedSensor = sensor.CommonTasks.SetPointingFixedAzEl(4.5, -45.0, AgEAzElAboutBoresight.eAzElAboutBoresightRotate);

Define location from Vector Geometry Tool point

[C#] Copy Code

// IAgSensor sensor: Sensor object


// Set location type to VGT

sensor.SetLocationType(AgESnLocation.eSnLocationCrdnPoint);


// Get IAgLocationCrdnPoint interface

IAgLocationCrdnPoint vgtPoint = sensor.LocationData as IAgLocationCrdnPoint;


// point sensor to an already existing object

vgtPoint.PointPath = "Facility/Facility1 Center";

Define location on 3D model

[C#] Copy Code

// IAgSensor sensor: Sensor object


// Set pointing type to 3d model

sensor.SetPointingType(AgESnPointing.eSnPt3DModel);


// Point to model attach point (in this example: "SolarArrays-000000")

IAgSnPt3DModel model = sensor.CommonTasks.SetPointing3DModel("Solar_PanelsNode");

Define sensor to use azimuth elevation mask file

[C#] Copy Code

// IAgSensor sensor: Sensor object

// String maskFilePath: Path to external az-el data file


// Specify Mask file

sensor.SetAzElMaskFile(maskFilePath);


// Get Mask File interface

IAgSnAzElMaskFile maskFile = sensor.AzElMaskData as IAgSnAzElMaskFile;


// Configure MaskFile as needed

maskFile.BoresightAxis = AgESnAzElBsightAxisType.ePlus_MinusZ;

Define spinning sensor pointing

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgSensor sensor: Sensor object


// Set pattern type to Spinning

sensor.SetPointingType(AgESnPointing.eSnPtSpinning);

IAgSnPtSpinning spinning = sensor.Pointing as IAgSnPtSpinning;


// Configure sensor

spinning.SpinAxisAzimuth = 14.24;

spinning.SpinAxisElevation = 7.68;

spinning.SpinAxisConeAngle = 42.46;

spinning.ScanMode = AgESnScanMode.eSnContinuous;

spinning.SpinRate = 88.921;

spinning.OffsetAngle = 110.44;

Define spinning sensor pointing (using common tasks)

[C#] Copy Code

// IAgSensor sensor: Sensor object


// Configure sensor (using common taks)

sensor.CommonTasks.SetPointingSpinning(

    14.24,

    7.68,

    42.46,

    AgESnScanMode.eSnContinuous,

    88.921,

    110.44,

    1.20,

    3.50);

Define targeted sensor pointing

[C#] Copy Code

// IAgSensor sensor: Sensor object


IAgSnPtTargeted targetedSensor = sensor.CommonTasks.SetPointingTargetedTracking(

    AgETrackModeType.eTrackModeTransmit, AgEBoresightType.eBoresightLevel, "*/AreaTarget/AreaTarget1");

Configure sensor 3D projection

[C#] Copy Code

// IAgSnVO sensorVo: Sensor VO object


sensorVo.ProjectionType = AgESnVOProjectionType.eProjectionAllIntersections;

sensorVo.InheritFrom2D = AgESnVOInheritFrom2D.eSnVOInheritFrom2DExtentOnly;

sensorVo.SpaceProjection = 2000.0;

Configure basic properties

[C#] Copy Code

// IAgStar star: Star object


// Units depend on current unit preferences

star.LocationDeclination = -40.0;

star.LocationRightAscension = 120.0; // in arcSec

star.Magnitude = -1.0;

star.Parallax = 0.0; // in arcSec

star.ProperMotionDeclination = 1.5; // in arcSec

star.ProperMotionRadialVelocity = 0.75; // in meters

star.ProperMotionRightAscension = -0.5; // in arcSec

Create a star (on current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create the Star

IAgStar star = root.CurrentScenario.Children.New(AgESTKObjectType.eStar, "MyStar") as IAgStar;

Create a star from a star database

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Import object from database using Connect

string command = "ImportFromDB * Star ScenarioCollection VisualMagnitude 0 1.0 RightAsc 200.0 230.0 Constellation ImportedFromStarDB";

root.ExecuteCommand(command);


IAgStar star = root.GetObjectFromPath("Star/Star-65474") as IAgStar;

Change a target position

[C#] Copy Code

// IAgTarget target: Target


IAgPosition pos = target.Position;

pos.AssignGeodetic(39.95, 15.58, 231.54);

Configure a target from azimuth mask file

[C#] Copy Code

// IAgTarget target: Target

// String maskfile: Path of maskfile


target.UseLocalTimeOffset = true;

target.LocalTimeOffset = 200.0;

target.UseTerrain = true;

// Note, if SetAzElMask is set to a type other than AgEAzElMaskType.eMaskFile,

// the second parameter is ignored.

target.SetAzElMask(AgEAzElMaskType.eMaskFile, maskfile);

target.TerrainNorm = AgETerrainNormType.eSlopeAzimuth;

target.AltRef = AgEAltRefType.eMSL;

target.HeightAboveGround = 1472.0;

Create a target (on the current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create the Target on the current scenario central body (use

// NewOnCentralBody to specify explicitly the central body)

IAgTarget areaTarget = root.CurrentScenario.Children.New(AgESTKObjectType.eAreaTarget, "MyAreaTarget") as IAgTarget;

Configure an aircraft route using the Great Arc propagator

[C#] Copy Code

// IAgAircraft aircraft: Aircraft object


// Set ship route to great arc

aircraft.SetRouteType(AgEVePropagatorType.ePropagatorGreatArc);


// Retrieve propagator interface

IAgVePropagatorGreatArc propagator = aircraft.Route as IAgVePropagatorGreatArc;

propagator.ArcGranularity = 51.333;


// Set Ref type to WayPtAltRefTerrain and retreive IAgVeWayPtAltitudeRefTerrain interface

propagator.SetAltitudeRefType(AgEVeAltitudeRef.eWayPtAltRefTerrain);

IAgVeWayPtAltitudeRefTerrain altRef = propagator.AltitudeRef as IAgVeWayPtAltitudeRefTerrain;

altRef.Granularity = 51.33;

altRef.InterpMethod = AgEVeWayPtInterpMethod.eWayPtEllipsoidHeight;


propagator.Method = AgEVeWayPtCompMethod.eDetermineTimeAccFromVel;


// Add waypoints

IAgVeWaypointsElement point1 = propagator.Waypoints.Add();

point1.Latitude = 39.7674;

point1.Longitude = -79.7292;

point1.Altitude = 3.0;

point1.Speed = 0.0772;


IAgVeWaypointsElement point2 = propagator.Waypoints.Add();

point2.Latitude = 38.3721;

point2.Longitude = -120.1160;

point2.Altitude = 3.0;

point2.Speed = 0.0772;


// Add more way points if necessary...


// Propagate

propagator.Propagate();

Set an aircraft to use Great Arc propagator

[C#] Copy Code

// IAgAircraft aircraft: Aircraft object


// Set ship route to great arc

aircraft.SetRouteType(AgEVePropagatorType.ePropagatorGreatArc);


// Retrieve propagator interface

IAgVePropagatorGreatArc propagator = aircraft.Route as IAgVePropagatorGreatArc;

Add ground ellipse element and data element

[C#] Copy Code

// IAgVeGroundEllipsesCollection ellipsesCollection: Ellipses collection


// Add ground ellipse

IAgVeGroundEllipseElement ellipse = ellipsesCollection.Add("MyEllipses");


// Add ellipse data element

IAgVeEllipseDataElement element = ellipse.EllipseData.Add();


// Configure element properties

element.Time = "1 Jan 2012 12:00:00.000";

element.Latitude = 35.2920;

element.Longitude = -93.7299;

element.SemiMajorAxis = 400.0;

element.SemiMinorAxis = 300.0;

element.Bearing = 35.71;

Export a vehicle attitude to an external file

[C#] Copy Code

// IAgScenario scenario: Current Scenario Object.

// IAgVeAttitudeExportTool attitudeExport: Attitude Export Tool


// Set and configure attitude coordinate axes

attitudeExport.SetCoordinateAxesType(AgEAttCoordinateAxes.eAttCoordinateAxesCustom);

IAgVeCoordinateAxesCustom customAxes = attitudeExport.CoordinateAxes as IAgVeCoordinateAxesCustom;

customAxes.ReferenceAxesName = "CentralBody/Sun J2000 Axes";


attitudeExport.VersionFormat = AgEExportToolVersionFormat.eExportToolVersionFormatCurrent;

attitudeExport.Include = AgEAttInclude.eAttIncludeQuaternionsAngularVelocity;


// Set the attitude file to use Scenario start and stop time

attitudeExport.TimePeriod.TimePeriodType = AgEExportToolTimePeriod.eExportToolTimePeriodSpecify;

attitudeExport.TimePeriod.Start = scenario.StartTime;

attitudeExport.TimePeriod.Stop = scenario.StopTime;


attitudeExport.StepSize.StepSizeType = AgEExportToolStepSize.eExportToolStepSizeSpecify;

attitudeExport.StepSize.Value = 3600;


// Save Attitude File

attitudeExport.Export("OMExternalFileAttitude.a");

Export a vehicle STK ephemeris to an external file

[C#] Copy Code

// IAgScenario scenario: Scenario object

// IAgVeEphemerisStkExportTool stkEphem: STK Ephemeris Export Tool

// String ephemFilePath: The fully qualified file path where the Ephemeris is to be exported to


// set export parameters

stkEphem.CoordinateSystem = AgEStkEphemCoordinateSystem.eStkEphemCoordinateSystemFixed;

stkEphem.IncludeInterp = true;

stkEphem.VersionFormat = AgEExportToolVersionFormat.eExportToolVersionFormatCurrent;

stkEphem.TimePeriod.TimePeriodType = AgEExportToolTimePeriod.eExportToolTimePeriodSpecify;


// Set the ephemeris to the Scenario start and stop times

stkEphem.TimePeriod.Start = scenario.StartTime;

stkEphem.TimePeriod.Stop = scenario.StopTime;


stkEphem.StepSize.StepSizeType = AgEExportToolStepSize.eExportToolStepSizeEphem;

stkEphem.Export(ephemFilePath);

Add attitude data based on a time-ordered set of Euler angles

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set Attitude to Standard

satellite.SetAttitudeType(AgEVeAttitude.eAttitudeStandard);

// Get IAgVeOrbitAttitudeStandard interface

IAgVeOrbitAttitudeStandard standard = satellite.Attitude as IAgVeOrbitAttitudeStandard;


// Set Profile to Inertially Fixed

standard.Basic.SetProfileType(AgEVeProfile.eProfileInertiallyFixed);

// Get IAgVeProfileInertial interface

IAgVeProfileInertial interfix = standard.Basic.Profile as IAgVeProfileInertial;


interfix.Inertial.AssignEulerAngles(AgEEulerOrientationSequence.e123, 20.1, 50.0, 20.0);

Add attitude data based on a time-ordered set of quaternions

[C#] Copy Code

// IAgSatellite satellite: Satellite object


satellite.SetAttitudeType(AgEVeAttitude.eAttitudeStandard);

IAgVeOrbitAttitudeStandard standard = satellite.Attitude as IAgVeOrbitAttitudeStandard;

standard.Basic.SetProfileType(AgEVeProfile.eProfileInertiallyFixed);

IAgVeProfileInertial interfix = standard.Basic.Profile as IAgVeProfileInertial;


interfix.Inertial.AssignQuaternion(-0.34298, -0.47081, 0.70345, 0.40725);

Add attitude data based on a time-ordered set of quaternions interpreted relative to CBF

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgSatellite satellite: Satellite object

// Array cpfQuaternion: Array that contains CPF Quaternion data


satellite.SetAttitudeType(AgEVeAttitude.eAttitudeRealTime);

IAgVeAttitudeRealTime realtime = satellite.Attitude as IAgVeAttitudeRealTime;


for (int i = 0; i < cpfQuaternion.GetUpperBound(0); i++)

{

    realtime.AddCBFQuaternion(

        cpfQuaternion.GetValue(i, 0),

        (double)cpfQuaternion.GetValue(i, 1),

        (double)cpfQuaternion.GetValue(i, 2),

        (double)cpfQuaternion.GetValue(i, 3),

        (double)cpfQuaternion.GetValue(i, 4));

}

Configure real-time attitude

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// set attitude type to real time

satellite.SetAttitudeType(AgEVeAttitude.eAttitudeRealTime);

IAgVeAttitudeRealTime realtime = satellite.Attitude as IAgVeAttitudeRealTime;


// Set our Attitude Look Ahead method to Extrapolate

realtime.LookAheadMethod = AgEVeLookAheadMethod.eExtrapolate;


// Duration

IAgVeDuration duration = realtime.Duration;

duration.LookAhead = 1600.0;

duration.LookBehind = 1600.0;


// BlockFactor

realtime.BlockFactor = 40;

realtime.DataReference.SetProfileType(AgEVeProfile.eProfileInertiallyFixed);

Set attitude profile type (if profile is supported)

[C#] Copy Code

// IAgSatellite satellite: Satellite object


IAgVeOrbitAttitudeStandard standard = satellite.Attitude as IAgVeOrbitAttitudeStandard;

if (standard.Basic.IsProfileTypeSupported(AgEVeProfile.eProfileSpinning))

{

    standard.Basic.SetProfileType(AgEVeProfile.eProfileSpinning);

}

Configure access intervals graphics

[C#] Copy Code

// IAgVeGfxAttributesAccess accessAttributes: Access Attributes graphics


accessAttributes.AccessObjects.Add("Satellite/sat1");


accessAttributes.DuringAccess.IsVisible = true;

accessAttributes.DuringAccess.Color = Color.Yellow;

accessAttributes.NoAccess.IsVisible = true;

accessAttributes.NoAccess.Color = Color.Red;

Configure basic graphics

[C#] Copy Code

// IAgVeGfxAttributesBasic basicAttributes: Basic Attributes graphics


// Change display

basicAttributes.IsVisible = true;

basicAttributes.Color = Color.Red;

basicAttributes.Line.Style = AgELineStyle.eDotted;

basicAttributes.Line.Width = AgELineWidth.e3;

basicAttributes.MarkerStyle = "Square";

Configure custom intervals graphics

[C#] Copy Code

// IAgVeGfxAttributesCustom customAttributes: Custom Attributes graphics


IAgVeGfxIntervalsCollection customIntervals = customAttributes.Intervals;


// Add intervals

customIntervals.Add("1 Jan 2012 12:00:00.000", "1 Jan 2012 14:00:00.000");

customIntervals.Add("2 Jan 2012 01:00:00.000", "2 Jan 2012 02:00:00.000");


// Deconflict intervals if necessary

customAttributes.Deconflict();

Configure elevation contours

[C#] Copy Code

// IAgVeGfxElevContours gfxContours: Gfx contours

// IAgVeVOElevContours voContours: VO contours


gfxContours.IsVisible = true;

gfxContours.IsFillVisible = true;

gfxContours.FillStyle = AgEFillStyle.eFillStyleHorizontalStripe;

gfxContours.NumOfDecimalDigits = 5;


// Add contour elevation level

IAgVeGfxElevationsElement elevation = gfxContours.Elevations.AddLevel(25.0);


// Configure contour elevation element

elevation.Color = Color.Red;

elevation.DistanceVisible = true;

elevation.LineStyle = AgELineStyle.eDotted;

elevation.LineWidth = AgELineWidth.e3;

elevation.UserTextVisible = true;

elevation.UserText = "My new elevation";


// Set contours to visible on scenario

voContours.IsVisible = true;

voContours.Fill = true;

voContours.FillTranslucency = 80.0;

Configure sunlight lighting graphics

[C#] Copy Code

// IAgVeGfxLighting lighting: Vehicle graphics lighting


IAgVeGfxLightingElement sunlight = lighting.Sunlight;


sunlight.Visible = true;

sunlight.Color = Color.Red;

sunlight.LineStyle = AgELineStyle.eDotted;

sunlight.LineWidth = AgELineWidth.e3;

sunlight.MarkerStyle = "Circle";

Set a vehicle's graphics to access intervals

[C#] Copy Code

// IAgGreatArcGraphics graphics: Great Arc graphics


if (graphics.IsAttributesTypeSupported(AgEVeGfxAttributes.eAttributesAccess))

{

    // Set graphics to access intervals

    graphics.SetAttributesType(AgEVeGfxAttributes.eAttributesAccess);


    // Get IAgVeGfxAttributesAccess interface

    IAgVeGfxAttributesAccess accessAttributes = graphics.Attributes as IAgVeGfxAttributesAccess;


    // adjust the access intervals graphics

}

Set a vehicle's graphics to basic

[C#] Copy Code

// IAgGreatArcGraphics graphics: Great Arc graphics


if (graphics.IsAttributesTypeSupported(AgEVeGfxAttributes.eAttributesBasic))

{

    // Set graphics to basic

    graphics.SetAttributesType(AgEVeGfxAttributes.eAttributesBasic);


    // Get IAgVeGfxAttributesBasic interface

    IAgVeGfxAttributesBasic basicAttributes = graphics.Attributes as IAgVeGfxAttributesBasic;


    // adjust the basic graphics

}

Set a vehicle's graphics to custom intervals

[C#] Copy Code

// IAgGreatArcGraphics graphics: Great Arc graphics


if (graphics.IsAttributesTypeSupported(AgEVeGfxAttributes.eAttributesCustom))

{

    // Set graphics to custom

    graphics.SetAttributesType(AgEVeGfxAttributes.eAttributesCustom);


    // Get IAgVeGfxAttributesCustom interface

    IAgVeGfxAttributesCustom customAttributes = graphics.Attributes as IAgVeGfxAttributesCustom;


    // adjust the custom intervals graphics

}

Configure 3D dropline graphics

[C#] Copy Code

// IAgVeVODropLinePathItem dropLine: Drop line


dropLine.IsVisible = true;

dropLine.Use2DColor = false;

dropLine.Color = Color.Red;

dropLine.LineStyle = AgELineStyle.eDashed;

dropLine.LineWidth = AgELineWidth.e4;

dropLine.Interval = 100.000; // in sec

Configure 3D pass graphics

[C#] Copy Code

// IAgVeVOPass pass: Vehicle pass


// Set lead data type to fraction, retrieved IAgVeGfxLeadData implementation

pass.TrackData.PassData.GroundTrack.SetLeadDataType(AgELeadTrailData.eDataQuarter);


pass.TrackData.PassData.GroundTrack.SetTrailDataType(AgELeadTrailData.eDataHalf);

pass.TrackData.PassData.Orbit.SetLeadDataType(AgELeadTrailData.eDataQuarter);

pass.TrackData.PassData.Orbit.SetTrailSameAsLead();


pass.TickMarks.GroundTrack.IsVisible = true;

pass.TickMarks.GroundTrack.SetTickDataType(AgETickData.eTickDataRadial);

pass.TickMarks.Orbit.IsVisible = true;

pass.TickMarks.Orbit.SetTickDataType(AgETickData.eTickDataRadialAndCrossTrack);

pass.TickMarks.TimeBetweenTicks = 180;

Configure control from a propagate segment with Design Explorer Optimizer

[C#] Copy Code

// IAgVAMCSTargetSequence sequence: Target sequence object


string deoStr = "Design Explorer Optimizer";


// Retrieve sequence profile

if (Array.IndexOf(sequence.Profiles.AvailableProfiles, deoStr) != -1)

{

    // Add a propagate segment on the Target Sequence in order to provide a control

    IAgVAMCSPropagate propagate = sequence.Segments.Insert(AgEVASegmentType.eVASegmentTypePropagate, "MyPropagate", "-") as IAgVAMCSPropagate;


    // Enable the propagate "StoppingConditions.Duration.TripValue" control

    IAgVAStoppingConditionElement durationControl = propagate.StoppingConditions["Duration"];

    durationControl.EnableControlParameter(AgEVAControlStoppingCondition.eVAControlStoppingConditionTripValue);


    IAgVAProfileDEOptimizer deo = sequence.Profiles.Add(deoStr) as IAgVAProfileDEOptimizer;


    // Retrieve result reference

    IAgVADEControlCollection controls = deo.ControlParameters;

    IAgVADEControl prop1Duration = controls.GetControlByPaths("MyPropagate", "StoppingConditions.Duration.TripValue");


    // Configure IAgVADEControl properties

    prop1Duration.Enable = true;

    prop1Duration.Perturbation = 0.01;

    prop1Duration.LowerBound = 0;

    prop1Duration.UpperBound = 43200;

    prop1Duration.ScalingMethod = AgEVADEScalingMethod.eVADEScalingMethodCustom;

    prop1Duration.ScalingValue = 0.000055;

}

Configure initial state segment

[C#] Copy Code

// IAgVADriverMCS driver: Astrogrator driver object


// Add a new segment and cast the segment to the IAgVAMCSInitialState interface

IAgVAMCSSegment segment = driver.MainSequence.Insert(AgEVASegmentType.eVASegmentTypeInitialState, "Inner Orbit", "-");

IAgVAMCSInitialState initState = segment as IAgVAMCSInitialState;


initState.CoordSystemName = "CentralBody/Earth Fixed";

initState.OrbitEpoch = "1 Jan 2012 12:00:00.000";


// Set element type and cast the Element property to the appropriate interface

// configure the element as necessary

initState.SetElementType(AgEVAElementType.eVAElementTypeCartesian);

IAgVAElementCartesian cartesian = initState.Element as IAgVAElementCartesian;

cartesian.Vx = 8051.21;

cartesian.Y = 55;

cartesian.Z = 0;

cartesian.Vx = 0.45;

cartesian.Vy = 8.10158;

cartesian.Vz = 3.51009;


// Configure fuel tank if necessary

initState.FuelTank.FuelDensity = 1001;

initState.FuelTank.FuelMass = 501;

initState.FuelTank.TankPressure = 5001;

initState.FuelTank.TankTemperature = 292;


// Configure spacecraft parameters

initState.SpacecraftParameters.Cd = 2.3;

initState.SpacecraftParameters.Ck = 1.1;

initState.SpacecraftParameters.Cr = 1.3;

initState.SpacecraftParameters.DragArea = 21;

initState.SpacecraftParameters.DryMass = 501;

initState.SpacecraftParameters.K1 = /*$k1$K1*/2;

initState.SpacecraftParameters.K2 = 3;

initState.SpacecraftParameters.RadiationPressureArea = 23.0;

initState.SpacecraftParameters.SolarRadiationPressureArea = 22.0;

Configure launch segment

[C#] Copy Code

// IAgVADriverMCS driver: Astrogrator driver object


// Add launch sequence and retrieve the

IAgVAMCSSegment segment = driver.MainSequence.Insert(AgEVASegmentType.eVASegmentTypeLaunch, "MyLaunch", "-");

IAgVAMCSLaunch launch = segment as IAgVAMCSLaunch;


// Configure launch properties

launch.CentralBodyName = "Mars";

launch.Epoch = "1 Jan 2012 12:00:00.000";

launch.StepSize = 6;

launch.UsePreviousSegmentState = false;

launch.PreLaunchTime = 1;

launch.TimeOfFlight = 500;

launch.AscentType = AgEVAAscentType.eVAAscentTypeEllipseQuarticMotion;

launch.InitialAcceleration = 0.02;


// Configure display type

launch.SetDisplaySystemType(AgEVALaunchDisplaySystem.eVADisplaySystemGeocentric);

IAgVADisplaySystemGeocentric llr = (IAgVADisplaySystemGeocentric)launch.DisplaySystem;

llr.Latitude = 35.581;

llr.Longitude = -92.263;

llr.Radius = 1000;


// Configure launch type

launch.AscentType = AgEVAAscentType.eVAAscentTypeEllipseQuarticMotion;

launch.InitialAcceleration = 0.02;

launch.AscentType = AgEVAAscentType.eVAAscentTypeEllipseCubicMotion;


// Configure burnout type

IAgVABurnoutVelocity velocity = launch.BurnoutVelocity;

velocity.BurnoutOption = AgEVABurnoutOptions.eVABurnoutOptionsInertialVelocity;

velocity.InertialVelocity = 20.0;

velocity.InertialHorizontalFPA = 22;

velocity.InertialVelocityAzimuth = 55;

velocity.BurnoutOption = AgEVABurnoutOptions.eVABurnoutOptionsFixedVelocity;

velocity.FixedVelocity = 20;

Configure maneuver segment

[C#] Copy Code

// IAgVADriverMCS driver: Astrogrator driver object


// Add launch sequence and retrieve the IAgVAMCSManeuver interface

IAgVAMCSSegment segment = driver.MainSequence.Insert(AgEVASegmentType.eVASegmentTypeManeuver, "MyManeuver", "-");

IAgVAMCSManeuver maneuver = segment as IAgVAMCSManeuver;


// Set Maneuver to Impulsive

maneuver.SetManeuverType(AgEVAManeuverType.eVAManeuverTypeImpulsive);

IAgVAManeuverImpulsive impulse = maneuver.Maneuver as IAgVAManeuverImpulsive;


// Set Impulsive attitude to VelocityVector

impulse.SetAttitudeControlType(AgEVAAttitudeControl.eVAAttitudeControlVelocityVector);

IAgVAAttitudeControlImpulsiveVelocityVector velVec = impulse.AttitudeControl as IAgVAAttitudeControlImpulsiveVelocityVector;

velVec.DeltaVMagnitude = 1.0;


impulse.SetPropulsionMethod(AgEVAPropulsionMethod.eVAPropulsionMethodThrusterSet, "Thruster Set");

impulse.UpdateMass = true;

Configure propagate segment

[C#] Copy Code

// IAgVADriverMCS driver: Astrogrator driver object


// Add a propagate segment to our sequence

IAgVAMCSSegment segment = driver.MainSequence.Insert(AgEVASegmentType.eVASegmentTypePropagate, "Propagate", "-");

IAgVAMCSPropagate propagate = segment as IAgVAMCSPropagate;

propagate.PropagatorName = "Earth Point Mass";


// Configure propagtor advanced properties

propagate.MinPropagationTime = 0;

propagate.EnableMaxPropagationTime = true;

propagate.MaxPropagationTime = 72000000;

propagate.EnableWarningMessage = true;


// Configure stopping conditions

IAgVAStoppingCondition duration = propagate.StoppingConditions["Duration"].Properties as IAgVAStoppingCondition;

duration.Trip = 7200;

duration.Tolerance = 0.00001;


// Add any addition stopping conditions

IAgVAStoppingCondition lightning = propagate.StoppingConditions.Add("Lighting") as IAgVAStoppingCondition;

Configure result from a maneuver segment with Design Explorer Optimizer

[C#] Copy Code

// IAgVAMCSTargetSequence sequence: Target sequence object


// Add a maneuver segment on the Target Sequence in order to provide access result

IAgVAMCSManeuver maneuver = sequence.Segments.Insert(AgEVASegmentType.eVASegmentTypeManeuver, "MyManeuver", "-") as IAgVAMCSManeuver;


// Add results the Access result to the manuever

((IAgVAMCSSegment)maneuver).Results.Add("Access/Access");


string deoStr = "Design Explorer Optimizer";


// Retrieve sequence profile

if (Array.IndexOf(sequence.Profiles.AvailableProfiles, deoStr) != -1)

{

    IAgVAProfileDEOptimizer deo = sequence.Profiles.Add(deoStr) as IAgVAProfileDEOptimizer;


    // Retrieve result reference

    IAgVADEResult altitudeResult = deo.Results.GetResultByPaths("MyManeuver", "Access");


    // Configure VADEResult properties


    altitudeResult.Enable = true;

    altitudeResult.Goal = AgEVADEGoal.eVADEGoalMaximize;

    altitudeResult.Weight = 2.00000;

    altitudeResult.ScalingMethod = AgEVADEScalingMethod.eVADEScalingMethodInitialValue;

}

Configure sequence segment with scripting tool

[C#] Copy Code

// IAgVADriverMCS driver: Astrogrator driver object


// Add launch sequence and retrieve the

IAgVAMCSSegment segment = driver.MainSequence.Insert(AgEVASegmentType.eVASegmentTypeSequence, "MySequence", "-");

IAgVAMCSSequence sequence = segment as IAgVAMCSSequence;


IAgVAScriptingTool scriptTool = sequence.ScriptingTool;

scriptTool.Enable = true;

scriptTool.LanguageType = AgEVALanguage.eVALanguageVBScript;

scriptTool.ScriptText(

@"

DeltaArg = dArg


&#39;  Set the optimizers desired results

DEOdArgUB = DeltaArg

DEOdArgLB = DeltaArg



&#39;  Initial guess tool:

&#39;  Assume transfer orbit is something like a circular orbit linking apoapse of initial orbit to apoapse of final orbit

&#39;  Constants:

mu = 398600

pi = 3.14159265358979


&#39;  Step 1:  propagate to apoapsis

Prop1Dur = Period_0/2


&#39;  Step 2:  conditions at end of initial orbit:

SMA_0 = 0.5*(RadApo_0 + RadPeri_0)

VelApo_0 = sqr( (RadPeri_0*mu) / (RadApo_0*SMA_0) )


&#39;  Step 3:  evaluate properties of the circular transfer orbit

Rcirc = RadApo_0

Vcirc = sqr(mu/Rcirc)

PeriodCirc = 2*pi*Sqr( Rcirc*Rcirc*Rcirc / mu)


&#39;  Step 4:  set first maneuver to enter transfer orbit

Burn1X = Vcirc - VelApo_0

Burn1Z = 0


&#39;  Step 5:  propagate along transfer orbit the desired change in argument of periapse

If DeltaArg >= 0 Then

 TransferDur = PeriodCirc*(DeltaArg/360)

Else

 TransferDur = PeriodCirc*(360+DeltaArg)/360

End If


&#39; Step 6:  set second maneuver to enter desired final orbit

Burn2X = -Burn1X

Burn2Z = 0

");


// Configure the script tool's segments


IAgVAScriptingSegment burn1X = scriptTool.SegmentProperties.Add("Burn1X");


if (Array.IndexOf(burn1X.AvailableObjectNames, "Optimize_Delta_w.Burn1") != -1)

{

    burn1X.ObjectName = "Optimize_Delta_w.Burn1";

    burn1X.Attribute = "ImpulsiveMnvr.Cartesian.X";

    burn1X.Unit = "km/sec";

}


IAgVAScriptingCalcObject period0 = scriptTool.CalcObjects.Add("Period_0");

period0.CalcObjectName = "Segments/Value At Segment";

IAgVAStateCalcValueAtSegment valAtSeg = period0.CalcObject as IAgVAStateCalcValueAtSegment;

valAtSeg.CalcObjectName = "Keplerian Elems/Orbit Period";

Configure target sequence segment

[C#] Copy Code

// IAgVADriverMCS driver: Astrogrator driver object


// First add a sequence target

IAgVAMCSSegment segment = driver.MainSequence.Insert(AgEVASegmentType.eVASegmentTypeTargetSequence, "Start Transfer", "-");

IAgVAMCSTargetSequence targetSequence = segment as IAgVAMCSTargetSequence;


targetSequence.Action = AgEVATargetSeqAction.eVATargetSeqActionRunActiveProfiles;

targetSequence.WhenProfilesFinish = AgEVAProfilesFinish.eVAProfilesFinishRunToReturnAndContinue;

targetSequence.ContinueOnFailure = false;


// Add as many child segments to target

IAgVAMCSManeuver dv1 = targetSequence.Segments.Insert(AgEVASegmentType.eVASegmentTypeManeuver, "DV1", "-") as IAgVAMCSManeuver;

IAgVAMCSManeuver dv2 = targetSequence.Segments.Insert(AgEVASegmentType.eVASegmentTypeManeuver, "DV2", "-") as IAgVAMCSManeuver;


// Add more profiles if necessary

string profileName = "Change Maneuver Type";

if (Array.IndexOf(targetSequence.Profiles.AvailableProfiles, profileName) != -1)

{

    IAgVAProfile newProfile = targetSequence.Profiles.Add(profileName);

}


// Enable controls

dv1.EnableControlParameter(AgEVAControlManeuver.eVAControlManeuverImpulsiveCartesianX);

IAgVAProfileDifferentialCorrector dc = targetSequence.Profiles["Differential Corrector"] as IAgVAProfileDifferentialCorrector;

IAgVADCControl controlParam = dc.ControlParameters.GetControlByPaths("DV1", "ImpulsiveMnvr.Cartesian.X");

controlParam.Enable = true;

controlParam.MaxStep = 0.3;


// Enable results

((IAgVAMCSSegment)dv1).Results.Add("Epoch");

IAgVADCResult roaResult = dc.Results.GetResultByPaths("DV1", "Epoch");

roaResult.Enable = true;


// Confiure the differential corrector

dc.MaxIterations = 50;

dc.EnableDisplayStatus = true;

dc.Mode = AgEVAProfileMode.eVAProfileModeIterate;

targetSequence.Action = AgEVATargetSeqAction.eVATargetSeqActionRunActiveProfiles;

Configure target sequence with Differential Corrector profile

[C#] Copy Code

// IAgVADriverMCS driver: Astrogrator driver object


IAgVAMCSTargetSequence startTransfer = driver.MainSequence["Start Transfer"] as IAgVAMCSTargetSequence;


string dcString = "Differential Corrector";


if (Array.IndexOf(startTransfer.Profiles.AvailableProfiles, dcString) != -1)

{

    IAgVAProfileDifferentialCorrector dc = startTransfer.Profiles.Add(dcString) as IAgVAProfileDifferentialCorrector;


    // Configure differential corrector

    dc.ClearCorrectionsBeforeRun = true;

    dc.ConvergenceCriteria = AgEVAConvergenceCriteria.eVAConvervenceCriteriaEitherEqualityConstraintsOrControlParams;

    dc.EnableBPlaneNominal = false;

    dc.EnableBPlanePerturbations = false;

    dc.EnableDisplayStatus = true;

    dc.EnableHomotopy = true;

    dc.HomotopySteps = 2;

    dc.EnableHomotopy = false;

    dc.EnableLineSearch = true;

    dc.LineSearchLowerBound = 0.001;

    dc.LineSearchTolerance = 0.001;

    dc.LineSearchUpperBound = 5.0;

    dc.MaxLineSearchIterations = 5;

    dc.MaxIterations = 20;


    // Apply

    startTransfer.ApplyProfiles();

}

Configure the Astrogrator propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorAstrogator);


IAgVADriverMCS driver = satellite.Propagator as IAgVADriverMCS;


// Remove if necessary

driver.MainSequence.RemoveAll();


// Configure properties as necessarily

driver.Options.DrawTrajectoryIn3D = true;

driver.Options.GraphicsUpdateRate = 0.90;

driver.Options.UpdateAnimationTimeForAllObjects = false;

driver.Options.StoppingConditionTimeTolerance = 0.00000005;

driver.Options.EnableLogging = true;

Configure update segment

[C#] Copy Code

// IAgVADriverMCS driver: Astrogrator driver object


// Add launch sequence and retrieve the

IAgVAMCSSegment segment = driver.MainSequence.Insert(AgEVASegmentType.eVASegmentTypeUpdate, "MyUpdate", "-");

IAgVAMCSUpdate update = segment as IAgVAMCSUpdate;


// Specify the element to be changed, the action, and the value


// Add values

update.SetActionAndValue(AgEVAUpdateParam.eVAUpdateParamCd, AgEVAUpdateAction.eVAUpdateActionAddValue, 2);

update.SetActionAndValue(AgEVAUpdateParam.eVAUpdateParamFuelDensity, AgEVAUpdateAction.eVAUpdateActionAddValue, 1);


// Set to new value

update.SetActionAndValue(AgEVAUpdateParam.eVAUpdateParamTankPressure, AgEVAUpdateAction.eVAUpdateActionSetToNewValue, 6000);

update.SetActionAndValue(AgEVAUpdateParam.eVAUpdateParamTankTemp, AgEVAUpdateAction.eVAUpdateActionSetToNewValue, 5);


// Subtract values

update.SetActionAndValue(AgEVAUpdateParam.eVAUpdateParamSRPArea, AgEVAUpdateAction.eVAUpdateActionSubtractValue, 10);

update.SetActionAndValue(AgEVAUpdateParam.eVAUpdateParamSRPArea, AgEVAUpdateAction.eVAUpdateActionSubtractValue, 1);

Configure the Ballistic propagator

[C#] Copy Code

// IAgVePropagatorBallistic propagator: Ballistic propagator


propagator.Step = 30;

propagator.SetLaunchType(AgEVeLaunch.eLaunchLLA);


IAgVeLaunchLLA launch = propagator.Launch as IAgVeLaunchLLA;

launch.Lat = 30.338;

launch.Lon = 33.468;

launch.Alt = 1.5;


propagator.SetImpactLocationType(AgEVeImpactLocation.eImpactLocationPoint);


IAgVeImpactLocationPoint impactLocation = propagator.ImpactLocation as IAgVeImpactLocationPoint;

impactLocation.SetImpactType(AgEVeImpact.eImpactLLA);

impactLocation.SetLaunchControlType(AgEVeLaunchControl.eLaunchControlFixedDeltaV);


IAgVeImpactLLA impact = impactLocation.Impact as IAgVeImpactLLA;

impact.Lat = 25.474;

impact.Lon = 68.306;

impact.Alt = 0.0;


IAgVeLaunchControlFixedDeltaV fixedDeltaV = impactLocation.LaunchControl as IAgVeLaunchControlFixedDeltaV;

fixedDeltaV.DeltaV = 7.545;


propagator.Propagate();

Configure the GPS propagator with an almanac

[C#] Copy Code

// IAgVePropagatorGPS propagator: GPS propagator

// String almanacPath: Almanac path

// IAgStkObject scenario: Current scenario


// Configure properties

// Use the scenario's analysis interval

propagator.EphemerisInterval.SetImplicitInterval(scenario.Vgt.EventIntervals["AnalysisInterval"]);


// PRN must be set before configuring GPS almanac

propagator.PRN = Int32.Parse((string)propagator.AvailablePRNs.GetValue(0));


// Turn the Auto-update off

propagator.AutoUpdateEnabled = false;


// Specify a catalog

propagator.SpecifyCatalog.Filename = almanacPath;


// Configure the properties specific to the chosen almanac

switch (propagator.SpecifyCatalog.Properties.Type)

{

    case AgEVeGPSAlmanacType.eGPSAlmanacTypeSEM:

        {

            /* configure the SEM almanac */

            IAgVeGPSAlmanacPropertiesSEM sem = propagator.SpecifyCatalog.Properties as IAgVeGPSAlmanacPropertiesSEM;

            sem.ReferenceWeek = AgEGPSReferenceWeek.eGPSReferenceWeek22Aug1999;

            break;

        }

    case AgEVeGPSAlmanacType.eGPSAlmanacTypeSP3:

        {

            /* SP3 almanac contains no configurable properties */

            IAgVeGPSAlmanacPropertiesSP3 sp3 = propagator.SpecifyCatalog.Properties as IAgVeGPSAlmanacPropertiesSP3;

            break;

        }

    case AgEVeGPSAlmanacType.eGPSAlmanacTypeYUMA:

        {

            /* configure the YUMA almanac */

            IAgVeGPSAlmanacPropertiesYUMA yuma = propagator.SpecifyCatalog.Properties as IAgVeGPSAlmanacPropertiesYUMA;

            yuma.ReferenceWeek = AgEGPSReferenceWeek.eGPSReferenceWeek22Aug1999;

            break;

        }

}


// Propagate

propagator.Propagate();

Configure the Great Arc propagator with a list of waypoints

[C#] Copy Code

// IAgVePropagatorGreatArc propagator: Great arc propagator


// Array with waypoints to insert

object[,] waypoints = new object[,]

    {

        { 20.36, 19.410, -99.125, "1 Jan 2012 12:00:00.000" },

        { 20.30, 19.421, -99.135, "1 Jan 2012 13:00:00.000" },

        { 20.30, 19.434, -99.137, "1 Jan 2012 14:00:00.000" }

    };


propagator.Method = AgEVeWayPtCompMethod.eDetermineVelFromTime;


// Remove any previous waypoints

propagator.Waypoints.RemoveAll();


// Insert the waypoints

for (int i = 0; i < waypoints.GetLength(0); i++)

{

    IAgVeWaypointsElement waypoint = propagator.Waypoints.Add();

    waypoint.Altitude = (double) waypoints[i, 0];

    waypoint.Latitude = waypoints[i, 1];

    waypoint.Longitude = waypoints[i, 2];

    waypoint.Time = waypoints[i, 3];

}


// Propagate ground vehicle

propagator.Propagate();

Configure the Great Arc propagator with a list of waypoints and velocity

[C#] Copy Code

// IAgVePropagatorGreatArc propagator: Great arc propagator


// Array with waypoints to insert

// Consists of: altitude, latitude, longitude, speed

double[,] waypoints = new double[,]

    {

        { 20.36, 19.410, -99.125, 10.5 },

        { 20.30, 19.421, -99.135, 12.5 },

        { 20.30, 19.434, -99.137, 15.0 }

    };


propagator.Method = AgEVeWayPtCompMethod.eDetermineTimeAccFromVel;


// Remove any previous waypoints

propagator.Waypoints.RemoveAll();


// Insert the waypoints

for (int i = 0; i < waypoints.GetLength(0); i++)

{

    IAgVeWaypointsElement waypoint = propagator.Waypoints.Add();

    waypoint.Altitude = waypoints[i, 0];

    waypoint.Latitude = waypoints[i, 1];

    waypoint.Longitude = waypoints[i, 2];

    waypoint.Speed = waypoints[i, 3];

}


// Propagate ground vehicle

propagator.Propagate();

List all waypoints in a Waypoint Collection

[C#] Copy Code

// IAgVePropagatorGreatArc propagator: Great arc propagator


// Array with waypoints to insert

object[,] waypoints = new object[,]

    {

        { 20.36, 19.410, -99.125, "1 Jan 2012 12:00:00.000" },

        { 20.30, 19.421, -99.135, "1 Jan 2012 13:00:00.000" },

        { 20.30, 19.434, -99.137, "1 Jan 2012 14:00:00.000" }

    };


propagator.Method = AgEVeWayPtCompMethod.eDetermineVelFromTime;


// Remove any previous waypoints

propagator.Waypoints.RemoveAll();


// Insert the waypoints

for (int i = 0; i < waypoints.GetLength(0); i++)

{

    IAgVeWaypointsElement waypoint = propagator.Waypoints.Add();

    waypoint.Altitude = (double)waypoints[i, 0];

    waypoint.Latitude = waypoints[i, 1];

    waypoint.Longitude = waypoints[i, 2];

    waypoint.Time = waypoints[i, 3];

}


// List the waypoints after extracting them into an array

Array waypointArray = propagator.Waypoints.ToArray();

for (int j = 0; j < waypointArray.GetLength(0); ++j)

{

    Console.WriteLine("  Time: {0} Latitude: {1} Longitude: {2} Altitude: {3}",

        waypointArray.GetValue(j, 0),

        Convert.ToDouble(waypointArray.GetValue(j, 1)),

        Convert.ToDouble(waypointArray.GetValue(j, 2)),

        Convert.ToDouble(waypointArray.GetValue(j, 3)));

}

Set Waypoints (Derive Time and Acceleration from Velocity) and Propagate

[C#] Copy Code

// IAgVePropagatorGreatArc propagator: Great arc propagator


propagator.Method = AgEVeWayPtCompMethod.eDetermineTimeAccFromVel;


Array waypoints = Array.CreateInstance(typeof(object), 4, 6);


// Point #1

waypoints.SetValue(0.0, 0, 0); // Lat

waypoints.SetValue(0.0, 0, 1); // Lon

waypoints.SetValue(35000, 0, 2); // Alt

waypoints.SetValue(35, 0, 3); // Vel

waypoints.SetValue(0.0, 0, 4); // Acc

waypoints.SetValue(0.0, 0, 5); // Turn radius


// Point #2

waypoints.SetValue(0.1, 1, 0); // Lat

waypoints.SetValue(0.1, 1, 1); // Lon

waypoints.SetValue(35100, 1, 2); // Alt

waypoints.SetValue(35, 1, 3); // Vel

waypoints.SetValue(0.0, 1, 4); // Acc

waypoints.SetValue(0.2, 1, 5); // Turn radius


// Point #3

waypoints.SetValue(0.2, 2, 0); // Lat

waypoints.SetValue(0.2, 2, 1); // Lon

waypoints.SetValue(35200, 2, 2); // Alt

waypoints.SetValue(35, 2, 3); // Vel

waypoints.SetValue(0.0, 2, 4); // Acc

waypoints.SetValue(0.0, 2, 5); // Turn radius


// Point #4

waypoints.SetValue(0.0, 3, 0); // Lat

waypoints.SetValue(0.0, 3, 1); // Lon

waypoints.SetValue(35200, 3, 2); // Alt

waypoints.SetValue(35, 3, 3); // Vel

waypoints.SetValue(0.0, 3, 4); // Acc

waypoints.SetValue(0.0, 3, 5); // Turn radius


propagator.SetPointsSpecifyVelocityAndPropagate(ref waypoints);


Assert.AreEqual(4, propagator.Waypoints.Count);

Set Waypoints (Derive Time from Velocity and Acceleration) and Propagate

[C#] Copy Code

// IAgVePropagatorGreatArc propagator: Great arc propagator


propagator.Method = AgEVeWayPtCompMethod.eDetermineTimeFromVelAcc;


Array waypoints = Array.CreateInstance(typeof(object), 4, 5);

// Point #1

waypoints.SetValue(0.0, 0, 0); // Lat

waypoints.SetValue(0.0, 0, 1); // Lon

waypoints.SetValue(35000, 0, 2); // Alt

waypoints.SetValue(35, 0, 3); // Vel

waypoints.SetValue(0.0, 0, 4); // Turn radius

// Point #2

waypoints.SetValue(0.1, 1, 0); // Lat

waypoints.SetValue(0.1, 1, 1); // Lon

waypoints.SetValue(35100, 1, 2); // Alt

waypoints.SetValue(35, 1, 3); // Vel

waypoints.SetValue(0.2, 1, 4); // Turn radius

// Point #3

waypoints.SetValue(0.2, 2, 0); // Lat

waypoints.SetValue(0.2, 2, 1); // Lon

waypoints.SetValue(35200, 2, 2); // Alt

waypoints.SetValue(35, 2, 3); // Vel

waypoints.SetValue(0.0, 2, 4); // Turn radius

// Point #4

waypoints.SetValue(0.0, 3, 0); // Lat

waypoints.SetValue(0.0, 3, 1); // Lon

waypoints.SetValue(35200, 3, 2); // Alt

waypoints.SetValue(35, 3, 3); // Vel

waypoints.SetValue(0.0, 3, 4); // Turn radius


propagator.SetPointsSmoothRateAndPropagate(ref waypoints);


Assert.AreEqual(4, propagator.Waypoints.Count);

Set Waypoints (Derive Velocity from Time) and Propagate

[C#] Copy Code

// IAgVePropagatorGreatArc propagator: Great arc propagator


propagator.Method = AgEVeWayPtCompMethod.eDetermineVelFromTime;


Array waypoints = Array.CreateInstance(typeof(object), 4, 5);

// Point #1

waypoints.SetValue("17 Jan 2013 17:00:00.000", 0, 0); // Time

waypoints.SetValue(0.0, 0, 1); // Lat

waypoints.SetValue(0.0, 0, 2); // Lon

waypoints.SetValue(35000, 0, 3); // Alt

waypoints.SetValue(0.0, 0, 4); // Turn radius


// Point #2

waypoints.SetValue("17 Jan 2013 17:01:00.000", 1, 0); // Time

waypoints.SetValue(0.1, 1, 1); // Lat

waypoints.SetValue(0.1, 1, 2); // Lon

waypoints.SetValue(35100, 1, 3); // Alt

waypoints.SetValue(0.2, 1, 4); // Turn radius


// Point #3

waypoints.SetValue("17 Jan 2013 17:02:00.000", 2, 0); // Time

waypoints.SetValue(0.2, 2, 1); // Lat

waypoints.SetValue(0.2, 2, 2); // Lon

waypoints.SetValue(35200, 2, 3); // Alt

waypoints.SetValue(0.0, 2, 4); // Turn radius


// Point #4

waypoints.SetValue("17 Jan 2013 17:03:00.000", 3, 0); // Time

waypoints.SetValue(0.0, 3, 1); // Lat

waypoints.SetValue(0.0, 3, 2); // Lon

waypoints.SetValue(35200, 3, 3); // Alt

waypoints.SetValue(0.0, 3, 4); // Turn radius


propagator.SetPointsSpecifyTimeAndPropagate(ref waypoints);


Assert.AreEqual(4, propagator.Waypoints.Count);

Sets the ephemeris start time to an explicit time, and then add waypoints relative to that time.

[C#] Copy Code

// IAgVePropagatorGreatArc propagator: Great Arc propagator


// Set the epoch time to tomorrow.

IAgCrdnEventSmartEpoch startEpoch = propagator.EphemerisInterval.GetStartEpoch();

startEpoch.SetExplicitTime("Tomorrow");

propagator.EphemerisInterval.SetStartEpoch(startEpoch);


// Waypoints time start from explicit start time that we set above.

Array waypointsAndTimes = new object[,]

{

    { 40.329, -76.366, 0, 0.0154, 0 },

    { 40.380, -76.359, 0, 0.0154, 0 },

    { 40.406, -76.329, 0, 0.0154, 0 },

    { 40.417, -76.311, 0, 0.0154, 0 },

};


propagator.SetPointsSmoothRateAndPropagate(ref waypointsAndTimes);


for (int i = 0; i < propagator.Waypoints.Count; ++i)

{

    Console.WriteLine("Waypoint {0}, Lat = {1}, Lon = {2}, Time = {3}",

        i,

        propagator.Waypoints[i].Latitude,

        propagator.Waypoints[i].Longitude,

        propagator.Waypoints[i].Time);

}

Configure the HPOP propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set satellite propagator to HPOP

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorHPOP);


// Get IAgVePropagatorLOP interface

IAgVePropagatorHPOP hpopProp = satellite.Propagator as IAgVePropagatorHPOP;


// Configure force model

IAgVeHPOPForceModel hpopForceModel = hpopProp.ForceModel;

hpopForceModel.CentralBodyGravity.File = @"STKData\CentralBodies\Earth\GGM02C.grv";

hpopForceModel.CentralBodyGravity.MaxDegree = 45;

hpopForceModel.CentralBodyGravity.MaxOrder = 10;

hpopForceModel.CentralBodyGravity.UseOceanTides = true;


hpopForceModel.Drag.Use = true;

IAgVeHPOPDragModelSpherical hpopDragModel = hpopForceModel.Drag.DragModel as IAgVeHPOPDragModelSpherical;

hpopDragModel.Cd = 1.890000;

hpopDragModel.AreaMassRatio = 0.05;

hpopForceModel.Drag.AtmosphericDensityModel = AgEAtmosphericDensityModel.eMSIS90;


hpopForceModel.ThirdBodyGravity.RemoveThirdBody("Moon");


// Propagate

hpopProp.Propagate();

Configure the J2 Perturbation propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set propagator to SGP4

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorJ2Perturbation);


// J2 Perturbation propagator

IAgVePropagatorJ2Perturbation j2prop = satellite.Propagator as IAgVePropagatorJ2Perturbation;


// Configure time period

j2prop.EphemerisInterval.SetExplicitInterval("1 Jan 2012 12:00:00.000", "2 Jan 2012 12:00:00.000");

j2prop.Step = 60.0;


// Configure propagator initial state

IAgVeJxInitialState initial = j2prop.InitialState;

initial.Representation.Epoch = "1 Jan 2012 12:00:00.000";

initial.Representation.AssignCartesian(

    AgECoordinateSystem.eCoordinateSystemFixed,

    -1514.4,       // in km (assuming unit preferences set to km)

    -6790.1,       // in km

    -1.25,         // in km

    4.8151,        // in km/sec (assuming unit preferences set to km/sec)

    1.7710,        // in km/sec

    5.6414);       // in km/sec

initial.EllipseOptions = AgEVeEllipseOptions.eSecularlyPrecessing;


// Propagate

j2prop.Propagate();

Configure the J4 Perturbation propagator to a circular orbit

[C#] Copy Code

// IAgSatellite satellite: Satellite object

// Double incl: Inclination (default 45.0)

// Double altitude: Atitude (default 500 km)


satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorJ4Perturbation);

IAgVePropagatorJ4Perturbation prop = satellite.Propagator as IAgVePropagatorJ4Perturbation;


IAgOrbitStateClassical keplerian = prop.InitialState.Representation.ConvertTo(AgEOrbitStateType.eOrbitStateClassical) as IAgOrbitStateClassical;


keplerian.SizeShapeType = AgEClassicalSizeShape.eSizeShapeAltitude;

IAgClassicalSizeShapeAltitude size = keplerian.SizeShape as IAgClassicalSizeShapeAltitude;


size.ApogeeAltitude = altitude;

size.PerigeeAltitude = altitude;


keplerian.Orientation.Inclination = incl;

keplerian.Orientation.ArgOfPerigee = 0;

keplerian.Orientation.AscNodeType = AgEOrientationAscNode.eAscNodeRAAN;

(keplerian.Orientation.AscNode as IAgOrientationAscNodeRAAN).Value = 0;


keplerian.LocationType = AgEClassicalLocation.eLocationTrueAnomaly;

(keplerian.Location as IAgClassicalLocationTrueAnomaly).Value = 0;


prop.InitialState.Representation.Assign(keplerian);

prop.Propagate();

Configure the J4 Perturbation propagator to a critically inclined orbit

[C#] Copy Code

// IAgSatellite satellite: Satellite object

// Double apogeeAlt: Apogee altitude (default 12000 km)

// Double perigeeAlt: Perigee altitude (default 400 km)

// Double ascNodeLon: Longitude of ascending node (default -100 deg


satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorJ4Perturbation);

IAgVePropagatorJ4Perturbation prop = satellite.Propagator as IAgVePropagatorJ4Perturbation;


IAgOrbitStateClassical keplerian = prop.InitialState.Representation.ConvertTo(AgEOrbitStateType.eOrbitStateClassical) as IAgOrbitStateClassical;


keplerian.SizeShapeType = AgEClassicalSizeShape.eSizeShapeAltitude;

IAgClassicalSizeShapeAltitude size = keplerian.SizeShape as IAgClassicalSizeShapeAltitude;


size.ApogeeAltitude = apogeeAlt;

size.PerigeeAltitude = perigeeAlt;


keplerian.Orientation.Inclination = 63.434949;

keplerian.Orientation.ArgOfPerigee = 270.000000;

keplerian.Orientation.AscNodeType = AgEOrientationAscNode.eAscNodeLAN;

(keplerian.Orientation.AscNode as IAgOrientationAscNodeLAN).Value = ascNodeLon;


keplerian.LocationType = AgEClassicalLocation.eLocationTrueAnomaly;

(keplerian.Location as IAgClassicalLocationTrueAnomaly).Value = 90.000000;


prop.InitialState.Representation.Assign(keplerian);

prop.Propagate();

Configure the LOP propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set satellite propagator to LOP

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorLOP);


// Get IAgVePropagatorLOP interface

IAgVePropagatorLOP lopProp = satellite.Propagator as IAgVePropagatorLOP;


// Configure time period

lopProp.EphemerisInterval.SetExplicitInterval("1 Jan 2012 12:00:00.000", "2 Jan 2012 12:00:00.000");

lopProp.Step = 86400;


// Configure propagator initial state

IAgOrbitState orbit = lopProp.InitialState.Representation;

orbit.Epoch = "1 Jan 2012 12:00:00.000";

orbit.AssignCartesian(

    AgECoordinateSystem.eCoordinateSystemFixed,

    -1120.32,          // in km (assuming unit preferences set to km)

    -9520.84,         // in km

    0.129,      // in km

    2.155,      // in km/sec (assuming unit preferences set to km/sec)

    -1.54416,      // in km/sec

    5.668412);     // in km/sec


// Configure force model

IAgVeLOPForceModel lopForceModel = lopProp.ForceModel;

lopForceModel.CentralBodyGravity.MaxDegree = 15;

lopForceModel.CentralBodyGravity.MaxOrder = 8;

lopForceModel.Drag.Use = true;

lopForceModel.Drag.Cd = 3.55;

lopForceModel.SolarRadiationPressure.Use = true;

lopForceModel.SolarRadiationPressure.Cp = 1.1250;

lopForceModel.SolarRadiationPressure.AtmosHeight = 125;

lopForceModel.PhysicalData.DragCrossSectionalArea = 0.001555512;

lopForceModel.PhysicalData.SRPCrossSectionalArea = 0.001810026;

lopForceModel.PhysicalData.SatelliteMass = 1505.001;


// Propagate

lopProp.Propagate();

Add realtime LLA positions

[C#] Copy Code

// IAgVePropagatorRealtime propagator: Realtime Propagator


IAgVeRealtimeLLAPoints points = propagator.PointBuilder.LLA;

points.Add("1 Jan 2012 12:00:00.000", 39.693, -76.399, 0.039, 0.03458, 0.01223, 0.05402);

Add realtime LLA positions in batches

[C#] Copy Code

// IAgVePropagatorRealtime propagator: Realtime Propagator


// Add realtime LLA points in batches

Array times = new object[]

              {

                  "1 Jan 2012 12:00:00.000",

                  "1 Jan 2012 12:01:00.000",

                  "1 Jan 2012 12:02:00.000"

              };

Array lat = new object[]

            {

                39.693, 41.061, 39.925

            };

Array lon = new object[]

            {

                -76.399, -74.266, -78.578

            };

Array alt = new object[]

            {

                0.039, 0.0420, 0.281

            };

Array latrate = new object[]

                {

                    0.03458, 0.03215, 0.03188

                };

Array lonrate = new object[]

                {

                    0.01223, 0.01148, 0.01075

                };

Array altrate = new object[]

                {

                    0.05402, 0.05210, 0.05075

                };


IAgVeRealtimeLLAPoints points = propagator.PointBuilder.LLA;


// AddBatch expects each parameter to be a one dimensional array and all of the same length

points.AddBatch(ref times, ref lat, ref lon, ref alt, ref latrate, ref lonrate, ref altrate);

Configure the Realtime propagator

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// IAgVePropagatorRealtime propagator: Realtime propagator


// Set Realtime Propagator settings if they should be other than

// the defaults.

propagator.InterpolationOrder = 1;

propagator.TimeoutGap = 30.0;

propagator.TimeStep = 60.0;


// Since we want to use the Two Body Look Ahead Propagator, check

// to see that it is supported before we set the Realtime Propagator

// to use this look ahead type

if (propagator.IsLookAheadPropagatorSupported(AgELookAheadPropagator.eLookAheadTwoBody))

{

    // Set the look ahead type

    propagator.LookAheadPropagator = AgELookAheadPropagator.eLookAheadTwoBody;


    // Set the duration time to look ahead and look behind

    IAgVeDuration duration = propagator.Duration;

    duration.LookAhead = 3600.0;

    duration.LookBehind = 3600.0;


    // Apply the Realtime Propagator settings

    propagator.Propagate();

}

Configure the SGP4 propagator with file source

[C#] Copy Code

// IAgVePropagatorSGP4 propagator: An SGP4 propagator

// String tleFilePath: Path to the external TLE data file


// Configure propagator's TLE file path

propagator.CommonTasks.AddSegsFromFile("2215", tleFilePath);


// Propagate

propagator.Propagate();

Configure the SGP4 propagator with online source

[C#] Copy Code

// IAgVePropagatorSGP4 propagator: An SGP4 propagator


// Configure time period

propagator.EphemerisInterval.SetExplicitInterval("1 Jan 2012 12:00:00.000", "2 Jan 2012 12:00:00.000");

propagator.Step = 60.0;


// Add segments

propagator.CommonTasks.AddSegsFromOnlineSource("25544");


// Propagate

propagator.Propagate();

Set SGP4 to auto-update from file source

[C#] Copy Code

// IAgVePropagatorSGP4 propagator: SGP4 satellite propagator

// String fileUpdateSource: File update source


propagator.AutoUpdateEnabled = true;

propagator.AutoUpdate.SelectedSource = AgEVeSGP4AutoUpdateSource.eSGP4AutoUpdateSourceFile;

propagator.AutoUpdate.FileSource.Filename = fileUpdateSource;


// Preview TLEs (optional)

// Preview() returns a one dimension string of tles

Array tles = propagator.AutoUpdate.FileSource.Preview();


Regex rx = new Regex(@"^(?<ssc>[-]?\d+) (?<orbitepoch>[-]?\d+[.]?\d+) (?<revnumber>[-]?\d+)$");

foreach (object line in tles)

{

    Match m = rx.Match(line.ToString());

    Console.WriteLine("SCC: {0}, orbit epoch: {1}, rev number: {2}", m.Groups["ssc"], m.Groups["orbitepoch"], m.Groups["revnumber"]);

}


// Propagate

propagator.Propagate();

Set SGP4 to auto-update from online source

[C#] Copy Code

// IAgVePropagatorSGP4 propagator: SGP4 satellite propagator


propagator.AutoUpdateEnabled = true;

propagator.AutoUpdate.SelectedSource = AgEVeSGP4AutoUpdateSource.eSGP4AutoUpdateSourceOnline;


// Preview TLEs (optional)

// Preview() returns a one dimension string of tles

Array tles = propagator.AutoUpdate.FileSource.Preview();


Regex rx = new Regex(@"^(?<ssc>[-]?\d+) (?<orbitepoch>[-]?\d+[.]?\d+) (?<revnumber>[-]?\d+)$");

foreach (object line in tles)

{

    Match m = rx.Match(line.ToString());

    Console.WriteLine("SCC: {0}, orbit epoch: {1}, rev number: {2}", m.Groups["ssc"], m.Groups["orbitepoch"], m.Groups["revnumber"]);

}


// Propagate

propagator.Propagate();

Configure the Simple Ascent propagator

[C#] Copy Code

// IAgVePropagatorSimpleAscent propagator: The Simple Ascent Propagator


// Configure time period

propagator.EphemerisInterval.SetExplicitInterval("1 Jan 2012 12:00:00.000", "2 Jan 2012 12:00:00.000");

propagator.Step = 60.0;


// Set the initial state

propagator.InitialState.Launch.AssignGeodetic(38.3721, -77.6402, 25.0);

propagator.InitialState.Burnout.AssignGeodetic(48.1395, -82.5145, 25.0);

propagator.InitialState.BurnoutVel = 7.7258;


// Propagate

propagator.Propagate();

Configure the SPICE propagator

[C#] Copy Code

// IAgVePropagatorSPICE propagator: The SPICE propagator

// String spiceFile: Path of SPICE file


// Set the SPICE file

propagator.Spice = spiceFile;


// Configure time period

propagator.EphemerisInterval.SetExplicitInterval("1 Jan 2012 12:00:00.000", "2 Jan 2012 12:00:00.000");

propagator.Step = 60.0;

propagator.BodyName = "-200000";


// Propagate

propagator.Propagate();

Create a ground vehicle (on current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root


// Create the ground vehicle

IAgGroundVehicle launchVehicle = root.CurrentScenario.Children.New(AgESTKObjectType.eGroundVehicle,  "MyGroundVehicle") as IAgGroundVehicle;

Get the ground vehicle Attitude Export tool

[C#] Copy Code

// IAgGroundVehicle groundVehicle: GroundVehicle whose attitude we want to export


IAgVeAttitudeExportTool attExTool = groundVehicle.ExportTools.GetAttitudeExportTool();

Get the ground vehicle Propagator Definition Export tool

[C#] Copy Code

// IAgGroundVehicle groundVehicle: GroundVehicle whose propagator definition we want to export


IAgVePropDefExportTool attExTool = groundVehicle.ExportTools.GetPropDefExportTool();

Get the ground vehicle STK Ephemeris Export tool

[C#] Copy Code

// IAgGroundVehicle groundVehicle: GroundVehicle whose ephemeris we want to export


IAgVeEphemerisStkExportTool stkEphem = groundVehicle.ExportTools.GetEphemerisStkExportTool();

Set ground vehicle to use Great Arc propagator

[C#] Copy Code

// IAgGroundVehicle groundVehicle: Ground Vehicle object


// Set ground vehicle route to great arc

groundVehicle.SetRouteType(AgEVePropagatorType.ePropagatorGreatArc);


// Retrieve propagator interface if necessary

IAgVePropagatorGreatArc propagator = groundVehicle.Route as IAgVePropagatorGreatArc;

Set ground vehicle to use Realtime propagator

[C#] Copy Code

// IAgGroundVehicle groundVehicle: Ground Vehicle object


// Set ground vehicle route to STK External propagator

groundVehicle.SetRouteType(AgEVePropagatorType.ePropagatorRealtime);


// Retrieve propagator interface if necessary

IAgVePropagatorRealtime propagator = groundVehicle.Route as IAgVePropagatorRealtime;

Set ground vehicle to use STK External propagator

[C#] Copy Code

// IAgGroundVehicle groundVehicle: Ground Vehicle object


// Set groundVehicle route to STK External propagator

groundVehicle.SetRouteType(AgEVePropagatorType.ePropagatorStkExternal);


// Retrieve propagator interface if necessary

IAgVePropagatorStkExternal propagator = groundVehicle.Route as IAgVePropagatorStkExternal;

Create a launch vehicle (on current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root


// Create the Launch vehicle

IAgLaunchVehicle launchVehicle = root.CurrentScenario.Children.New(AgESTKObjectType.eLaunchVehicle,  "MyLaunchVehicle") as IAgLaunchVehicle;

Determine if trajectory type is supported

[C#] Copy Code

// IAgLaunchVehicle launchVehicle: Launch vehicle


bool supported = launchVehicle.IsTrajectoryTypeSupported(AgEVePropagatorType.ePropagatorRealtime);

Define missile trajectory

[C#] Copy Code

// IAgMissile missile: Chain object


// Set missile trajectory type

missile.SetTrajectoryType(AgEVePropagatorType.ePropagatorBallistic);


// Retrieve the Propagator interface

IAgVePropagatorBallistic trajectory = missile.Trajectory as IAgVePropagatorBallistic;


// Set propagator settings if they should be other than defaults

trajectory.EphemerisInterval.SetExplicitInterval("1 Jan 2012 12:00:00.000", "2 Jan 2012 12:00:00.000");

trajectory.Step = 60.0;


// Set flight parameters

trajectory.SetLaunchType(AgEVeLaunch.eLaunchLLA);

IAgVeLaunchLLA launch = trajectory.Launch as IAgVeLaunchLLA;

launch.Lat = 0.0;

launch.Lon = 0.0;

launch.Alt = 0.0;


// Set impact location type

trajectory.SetImpactLocationType(AgEVeImpactLocation.eImpactLocationPoint);


// Retrieve the impact point interface

IAgVeImpactLocationPoint impactLocation = trajectory.ImpactLocation as IAgVeImpactLocationPoint;

impactLocation.SetLaunchControlType(AgEVeLaunchControl.eLaunchControlFixedTimeOfFlight);


// Retrieve the launch flight interface

IAgVeLaunchControlFixedTimeOfFlight launchControl = impactLocation.LaunchControl as IAgVeLaunchControlFixedTimeOfFlight;

launchControl.TimeOfFlight = 9000.0;


// Configure missile Impact parameters

impactLocation.SetImpactType(AgEVeImpact.eImpactLLA);

IAgVeImpactLLA impact = impactLocation.Impact as IAgVeImpactLLA;

impact.Lat = 12.0;

impact.Lon = 5.0;

impact.Alt = 0.0;


// Propagate Missile

trajectory.Propagate();

Create a satellite (on current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create the Satellite

IAgSatellite satellite = root.CurrentScenario.Children.New(AgESTKObjectType.eSatellite, "MySatellite") as IAgSatellite;

Create a satellite from an external ephemeris file (.e)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// String ephemerisFilePath: Path to external ephemeris data file


IAgSatellite satellite = root.CurrentScenario.Children.New(AgESTKObjectType.eSatellite, "MySatellite") as IAgSatellite;


// Configure propagator's external file path

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorStkExternal);

IAgVePropagatorStkExternal ext = satellite.Propagator as IAgVePropagatorStkExternal;

ext.Filename = ephemerisFilePath;


// Propagate

ext.Propagate();

Create a satellite from the satellite database

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Get STK database location using Connect

IAgExecCmdResult result = root.ExecuteCommand("GetDirectory / Database Satellite");

string satDataDir = result[0];

string filelocation = "\"" + Path.Combine(satDataDir, @"stkAllTLE.sd") + "\"";

string commonname = "\"hst\"";


// Import object from database using Connect

string command = String.Format("ImportFromDB * Satellite {0} Constellation ImportedFromSatDB Propagate On CommonName {1}", filelocation, commonname);

root.ExecuteCommand(command);

Set the satellite to use the GPS propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set propagator to GPS

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorGPS);


// Get the GPS propagator

IAgVePropagatorGPS propagator = satellite.Propagator as IAgVePropagatorGPS;

Set the satellite to use the HPOP propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set satellite propagator to HPOP

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorHPOP);


// Get the HPOP propagator

IAgVePropagatorHPOP propagator = satellite.Propagator as IAgVePropagatorHPOP;

Set the satellite to use the J2 propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set propagator to J2 Perturbation

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorJ2Perturbation);


// Get the J2 Perturbation propagator

IAgVePropagatorJ2Perturbation propagator = satellite.Propagator as IAgVePropagatorJ2Perturbation;

Set the satellite to use the LOP propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set satellite propagator to LOP

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorLOP);


// Get the LOP propagator

IAgVePropagatorLOP propagator = satellite.Propagator as IAgVePropagatorLOP;

Set the satellite to use the SGP4 propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set propagator to SGP4

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorSGP4);


// Get the SGP4 propagator

IAgVePropagatorSGP4 propagator = satellite.Propagator as IAgVePropagatorSGP4;

Set the satellite to use the SPICE propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set propagator to SPICE

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorSPICE);


// Get the SPICE propagator

IAgVePropagatorSPICE propagator = satellite.Propagator as IAgVePropagatorSPICE;

Set the satellite to use the STK External propagator

[C#] Copy Code

// IAgSatellite satellite: Satellite object


// Set propagator to STK External

satellite.SetPropagatorType(AgEVePropagatorType.ePropagatorStkExternal);


// Get the STK External propagator

IAgVePropagatorStkExternal propagator = satellite.Propagator as IAgVePropagatorStkExternal;

Create a ship (on current scenario central body)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root


// Create the Ship

IAgShip ship = root.CurrentScenario.Children.New(AgESTKObjectType.eShip, "MyShip") as IAgShip;

Set ship to use Great Arc propagator

[C#] Copy Code

// IAgShip ship: Ship object


// Set ship route to great arc

ship.SetRouteType(AgEVePropagatorType.ePropagatorGreatArc);


// Retrieve propagator interface if necessary

IAgVePropagatorGreatArc propagator = ship.Route as IAgVePropagatorGreatArc;

Set ship to use Realtime propagator

[C#] Copy Code

// IAgShip ship: Ship object


// Set ship route to STK External propagator

ship.SetRouteType(AgEVePropagatorType.ePropagatorRealtime);


// Retrieve propagator interface if necessary

IAgVePropagatorRealtime propagator = ship.Route as IAgVePropagatorRealtime;

Set ship to use STK External propagator

[C#] Copy Code

// IAgShip ship: Ship object


// Set ship route to STK External propagator

ship.SetRouteType(AgEVePropagatorType.ePropagatorStkExternal);


// Retrieve propagator interface if necessary

IAgVePropagatorStkExternal propagator = ship.Route as IAgVePropagatorStkExternal;

Add an Attribute that provides a combobox of values from which the user can choose.

[C#] Copy Code


//Add the following code to your plugin

public object Choice { get; set; }

public object[] Choices = new object[4] { "0", "1", "2", "3" };



public object GetPluginConfig(AGI.Attr.AgAttrBuilder pAttrBuilder)

{

    if (m_AgAttrScope == null)

    {

        m_AgAttrScope = pAttrBuilder.NewScope();

        pAttrBuilder.AddChoicesDispatchProperty(m_AgAttrScope, "Choice", "A property", "Choice", Choices);

    }


    return m_AgAttrScope;

}

Add an Attribute that provides a combobox of values populated by a function from which the user can choose.

[C#] Copy Code


//Add the following code to your plugin

public object Choice { get; set; }

public object[] Choices

{

    get

    {

        return new object[4] { "0", "1", "2", "3" };

    }

}



public object GetPluginConfig(AGI.Attr.AgAttrBuilder pAttrBuilder)

{

    if (m_AgAttrScope == null)

    {

        m_AgAttrScope = pAttrBuilder.NewScope();

        pAttrBuilder.AddChoicesFuncDispatchProperty(m_AgAttrScope, "Choice", "A property", "Choice", "Choices");

    }


    return m_AgAttrScope;

}

Shows the format of the Center parameter when creating a bounding sphere.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array center = new object[]

{

    1247.87,

    -4739.74,

    4067.77

};


IAgStkGraphicsBoundingSphere boundingSphere = sceneManager.Initializers.BoundingSphere.Initialize(ref center, 100);

Shows the format of the Size parameter when computing using a box triangulator.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array size = new object[]

{

    1000,

    1000,

    2000

};


IAgStkGraphicsSolidTriangulatorResult result = sceneManager.Initializers.BoxTriangulator.Compute(ref size);

Change view mode to use Earth's fixed frame

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


scene.Camera.ViewCentralBody("Earth", root.VgtRoot.WellKnownAxes.Earth.Fixed);

Shows the format of the Camera's Position property.

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene


Array position = new object[]

{

    31378.1,

    0,

    0

};


scene.Camera.Position = position;

Shows the format of the Camera's ReferencePoint property.

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene


Array point = new object[]

{

    31378.1,

    0,

    0

};


scene.Camera.ReferencePoint = point;

Shows the format of the Camera's UpVector property.

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene


Array upVector = new object[]

{

    0,

    0,

    1

};


scene.Camera.UpVector = upVector;

Shows the format of the Extent parameter when zooming to a cartographic extent on a central body.

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene


Array extent = new object[]

{

    90,

    30,

    -77,

    39

};


scene.Camera.ViewExtent(

    "Earth",

    ref extent);

Shows the format of the Offset and UpAxis parameters when setting the camera's reference point with an offset.

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// IAgCrdnPoint point: A valid VGT point object.

// IAgCrdnAxes axes: A valid VGT axes object.


Array offset = new object[]

{

    50.0,

    50.0,

    -50.0

};


Array upAxis = new object[]

{

    0,

    0,

    1

};


scene.Camera.ViewOffsetWithUpAxis(

    axes,

    point,

    ref offset,

    ref upAxis);

Shows the format of the Position parameter when converting a cartogaphic position to a pixel coordinate.

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene


Array position = new object[]

{

    0.627,

    -1.644,

    0

};


Array windowPos = scene.Camera.CartographicToWindow(

    "Earth",

    ref position);

Shows the format of the Position parameter when converting a pixel coordinate to a cartographic position.

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene


Array position = new object[]

{

    150,

    116

};


Array cartographicPos = scene.Camera.WindowToCartographic(

    "Earth",

    ref position);

Take a snapshot of the camera's view

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


//

// The snapshot can be saved to a file, texture, image, or the clipboard

//

IAgStkGraphicsRendererTexture2D texture = scene.Camera.Snapshot.SaveToTexture();


IAgStkGraphicsTextureScreenOverlay textureScreenOverlay = manager.Initializers.TextureScreenOverlay.InitializeWithXYTexture(0, 0, texture);

IAgStkGraphicsOverlay overlay = (IAgStkGraphicsOverlay)textureScreenOverlay;

overlay.BorderSize = 2;

overlay.BorderColor = Color.White;

overlay.Scale = 0.2;

overlay.Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginCenter;

IAgStkGraphicsScreenOverlayCollectionBase screenOverlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays;

screenOverlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Shows the format of the ConvolutionFilter's Kernel property.

[C#] Copy Code

// IAgStkGraphicsConvolutionFilter convolutionFilter: A valid convolution filter


Array kernel = new object[] {

    1, 1, 1,

    1, 1, 1,

    1, 1, 1

};


convolutionFilter.Kernel = kernel;

Shows the format of the Kernel parameter when creating a convolution filter.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array kernel = new object[] {

    1, 1, 1,

    1, 1, 1,

    1, 1, 1

};


IAgStkGraphicsConvolutionFilter convolutionFilter = sceneManager.Initializers.ConvolutionFilter.InitializeWithKernel(ref kernel);

Shows the format of the distance to position display condition's Position property.

[C#] Copy Code

// IAgStkGraphicsDistanceToPositionDisplayCondition condition: A distance to position display condition


Array position = new object[]

{

    6700,

    0,

    0

};


condition.Position = position;

Shows the format of the Position parameter when creating a distance to position display condition.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array position = new object[]

{

    6700,

    0,

    0

};


IAgStkGraphicsDistanceToPositionDisplayCondition condition = sceneManager.Initializers.DistanceToPositionDisplayCondition.InitializeWithDistances(

    ref position,

    0,

    10000);

Draw a primitive based on a time interval

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String globeOverlayFile: Location of the globe overlay file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsGeospatialImageGlobeOverlay overlay = manager.Initializers.GeospatialImageGlobeOverlay.InitializeWithString(globeOverlayFile);


IAgDate start = root.ConversionUtility.NewDate("UTCG", "30 May 2008 14:30:00.000");

IAgDate end = root.ConversionUtility.NewDate("UTCG", "30 May 2008 15:00:00.000");


((IAgScenario)root.CurrentScenario).Animation.StartTime = double.Parse(start.Subtract("sec", 3600).Format("epSec"));


IAgStkGraphicsTimeIntervalDisplayCondition condition =

    manager.Initializers.TimeIntervalDisplayCondition.InitializeWithTimes(start, end);

((IAgStkGraphicsGlobeOverlay)overlay).DisplayCondition = condition as IAgStkGraphicsDisplayCondition;


scene.CentralBodies.Earth.Imagery.Add((IAgStkGraphicsGlobeImageOverlay)overlay);

Draw a primitive based on multiple conditions

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String modelFile: Location of the model file

// IAgCrdnAxesFixed axes: An axes used to orient the model


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array position = new object[] {29.98, -90.25, 0.0 };


IAgStkGraphicsModelPrimitive model = manager.Initializers.ModelPrimitive.InitializeWithStringUri(

    modelFile);

model.SetPositionCartographic("Earth", ref position);

model.Scale = Math.Pow(10, 1.5);


IAgDate start1 = root.ConversionUtility.NewDate("UTCG", "30 May 2008 14:00:00.000");

IAgDate end1 = root.ConversionUtility.NewDate("UTCG", "30 May 2008 14:30:00.000");

((IAgAnimation)root).CurrentTime = double.Parse(start1.Format("epSec"));

IAgDate start2 = root.ConversionUtility.NewDate("UTCG", "30 May 2008 15:00:00.000");

IAgDate end2 = root.ConversionUtility.NewDate("UTCG", "30 May 2008 15:30:00.000");


IAgStkGraphicsTimeIntervalDisplayCondition time1 = manager.Initializers.TimeIntervalDisplayCondition.InitializeWithTimes(start1, end1);

IAgStkGraphicsTimeIntervalDisplayCondition time2 = manager.Initializers.TimeIntervalDisplayCondition.InitializeWithTimes(start2, end2);

IAgStkGraphicsCompositeDisplayCondition composite = manager.Initializers.CompositeDisplayCondition.Initialize();


composite.Add((IAgStkGraphicsDisplayCondition)time1);

composite.Add((IAgStkGraphicsDisplayCondition)time2);

composite.LogicOperation = AgEStkGraphicsBinaryLogicOperation.eStkGraphicsBinaryLogicOperationOr;

((IAgStkGraphicsPrimitive)model).DisplayCondition = composite as IAgStkGraphicsDisplayCondition;


IAgCrdnAxesFindInAxesResult result = root.VgtRoot.WellKnownAxes.Earth.Fixed.FindInAxes(((IAgScenario)root.CurrentScenario).Epoch, ((IAgCrdnAxes)axes));

model.Orientation = result.Orientation;


manager.Primitives.Add((IAgStkGraphicsPrimitive)model);

Draw a primitive based on viewer altitude

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array extent = new object[]

{

    -94, 29,

    -89, 33

};


IAgStkGraphicsSurfaceTriangulatorResult triangles = manager.Initializers.SurfaceExtentTriangulator.ComputeSimple("Earth", ref extent);


IAgStkGraphicsPolylinePrimitive line = manager.Initializers.PolylinePrimitive.Initialize();

Array boundaryPositions = triangles.BoundaryPositions;

line.Set(ref boundaryPositions);

((IAgStkGraphicsPrimitive)line).Color = Color.White;


IAgStkGraphicsAltitudeDisplayCondition condition = manager.Initializers.AltitudeDisplayCondition.InitializeWithAltitudes(500000, 2500000);

((IAgStkGraphicsPrimitive)line).DisplayCondition = condition as IAgStkGraphicsDisplayCondition;


manager.Primitives.Add((IAgStkGraphicsPrimitive)line);

Draw a primitive based on viewer distance

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String modelFile: Location of the model file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsModelPrimitive model = manager.Initializers.ModelPrimitive.InitializeWithStringUri(

    modelFile);

Array position = new object[3] { 29.98, -90.25, 8000.0 };

model.SetPositionCartographic("Earth", ref position);

model.Scale = Math.Pow(10, 3);


IAgStkGraphicsDistanceDisplayCondition condition =

    manager.Initializers.DistanceDisplayCondition.InitializeWithDistances(2000, 40000);

((IAgStkGraphicsPrimitive)model).DisplayCondition = condition as IAgStkGraphicsDisplayCondition;


manager.Primitives.Add((IAgStkGraphicsPrimitive)model);

Draw a screen overlay based on viewer distance

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// IAgStkGraphicsModelPrimitive model: A model

// IAgStkGraphicsScreenOverlay overlay: A overlay


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;


IAgStkGraphicsDistanceToPrimitiveDisplayCondition condition =

    manager.Initializers.DistanceToPrimitiveDisplayCondition.InitializeWithDistances(

    (IAgStkGraphicsPrimitive)model, 0, 40000);

((IAgStkGraphicsOverlay)overlay).DisplayCondition = (IAgStkGraphicsDisplayCondition)condition;


manager.Primitives.Add((IAgStkGraphicsPrimitive)model);

overlayManager.Add(overlay);

Shows the format of the TimeInterval parameter when creating a time interval display condition.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array timeInterval = new object[]

{

    "1 Jan 2012 12:00:00.000",

    "1 Jan 2012 14:00:00.000"

};


sceneManager.Initializers.TimeIntervalDisplayCondition.InitializeWithTimeInterval(ref timeInterval);

Shows the format of the Radii parameter when computing using an ellipsoid triangulator.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array radii = new object[]

{

    2000,

    1000,

    1000

};


IAgStkGraphicsSolidTriangulatorResult result = sceneManager.Initializers.EllipsoidTriangulator.ComputeSimple(ref radii);

Shows the format of the BottomPositions and TopPositions parameters when computing using an extruded polyline triangulator with cartographic positions.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array bottomPositions = new object[]

{

    0, 0, 200000,

    0.1, 0.1, 200000,

    0, 0.1, 200000,

    0, 0, 200000

};


Array topPositions = new object[]

{

    0.1, 0.1, 900000,

    0.2, 0.2, 900000,

    0.1, 0.2, 900000,

    0.1, 0.1, 900000

};


IAgStkGraphicsExtrudedPolylineTriangulatorResult result = sceneManager.Initializers.ExtrudedPolylineTriangulator.ComputeCartographic(

    "Earth",

    ref bottomPositions,

    ref topPositions);

Shows the format of the BottomPositions and TopPositions parameters when computing using an extruded polyline triangulator.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array bottomPositions = new object[]

{

    6578.14, 0, 0,

    6512.79, 653.458, 652.476,

    6545.27, 656.718, 0,

    6578.14, 0, 0

};


Array topPositions = new object[]

{

    7205.81, 722.992, 722.36,

    6991.68, 1417.28, 1437.63,

    7097.63, 1438.76, 722.36,

    7205.81, 722.992, 722.36

};


IAgStkGraphicsExtrudedPolylineTriangulatorResult result = sceneManager.Initializers.ExtrudedPolylineTriangulator.Compute(

    "Earth",

    ref bottomPositions,

    ref topPositions);

Shows the format of the Positions parameter when computing using an extruded polyline triangulator with altitudes and cartographic positions.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array positions = new object[]

{

    0, 0, 200000,

    0.1, 0.1, 200000,

    0, 0.1, 200000,

    0, 0, 200000

};


IAgStkGraphicsExtrudedPolylineTriangulatorResult result = sceneManager.Initializers.ExtrudedPolylineTriangulator.ComputeCartographicWithAltitudes(

    "Earth",

    ref positions,

    0,

    100);

Shows the format of the Positions parameter when computing using an extruded polyline triangulator with altitudes.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array positions = new object[]

{

    6578.14, 0, 0,

    6512.79, 653.458, 652.476,

    6545.27, 656.718, 0,

    6578.14, 0, 0

};


IAgStkGraphicsExtrudedPolylineTriangulatorResult result = sceneManager.Initializers.ExtrudedPolylineTriangulator.ComputeWithAltitudes(

    "Earth",

    ref positions,

    0,

    100);

Shows the format of the Positions parameter when computing using an extruded polyline triangulator with cartographic positions.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array positions = new object[]

{

    0, -0.0079, 15000,

    -0.0078, 0, 45000,

    0, 0.0079, 15000,

    0, 0, 45000,

    0, -0.0079, 15000

};


IAgStkGraphicsExtrudedPolylineTriangulatorResult result = sceneManager.Initializers.ExtrudedPolylineTriangulator.ComputeSingleConstantAltitudeCartographic(

    "Earth",

    ref positions,

    30000);

Shows the format of the Positions parameter when computing using an extruded polyline triangulator.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array positions = new object[]

{

    6392.94, -50.5053, 0,

    6422.94, 0, -49.7669,

    6392.94, 50.5053, 0,

    6422.94, 0, 49.7669,

    6392.94, -50.5053, 0

};


IAgStkGraphicsExtrudedPolylineTriangulatorResult result = sceneManager.Initializers.ExtrudedPolylineTriangulator.ComputeSingleConstantAltitude(

    "Earth",

    ref positions,

    30000);

Add custom imagery to the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsCustomImageGlobeOverlayPluginActivator activator =

    manager.Initializers.CustomImageGlobeOverlayPluginActivator.Initialize();

IAgStkGraphicsCustomImageGlobeOverlayPluginProxy proxy =

    activator.CreateFromDisplayName("OpenStreetMapPlugin.CSharp");


IAgStkGraphicsCustomImageGlobeOverlay overlay = proxy.CustomImageGlobeOverlay;

scene.CentralBodies.Earth.Imagery.Add((IAgStkGraphicsGlobeImageOverlay)overlay);

Add jp2 imagery to the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String globeOverlayFile: The globe overlay file


//

// Either jp2 or pdttx can be used here

//

IAgStkGraphicsGlobeImageOverlay overlay = scene.CentralBodies.Earth.Imagery.AddUriString(globeOverlayFile);

Add terrain to the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String terrainOverlayFile: The terrain overlay file


IAgStkGraphicsTerrainOverlay overlay = scene.CentralBodies.Earth.Terrain.AddUriString(

    terrainOverlayFile);

Draw an image on top of another

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String topOverlayFile: The top globe overlay file

// String bottomOverlayFile: The bottom globe overlay file


IAgStkGraphicsGlobeImageOverlay topOverlay = scene.CentralBodies.Earth.Imagery.AddUriString(topOverlayFile);

IAgStkGraphicsGlobeImageOverlay bottomOverlay = scene.CentralBodies.Earth.Imagery.AddUriString(bottomOverlayFile);


//

// Since bottom.jp2 was added after top.jp2, bottom.jp2 will be

// drawn on top.  In order to draw top.jp2 on top, we swap the Overlays.

//

scene.CentralBodies.Earth.Imagery.Swap(topOverlay, bottomOverlay);

Shows the format of the Extent parameter when creating a raster imgae globe overlay.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array extent = new object[]

{

    90,

    30,

    -77,

    39

};


IAgStkGraphicsRasterImageGlobeOverlay overlay = sceneManager.Initializers.RasterImageGlobeOverlay.InitializeWithColor(

    Color.Red,

    ref extent);

Adjust brightness, contrast, and gamma

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: The image file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;

//

// The URI can be a file path, http, https, or ftp location

//

IAgStkGraphicsRaster image = manager.Initializers.Raster.InitializeWithStringUri(

    imageFile);


//

// Add brightness, contrast, and gamma correction filters to sequence

//

IAgStkGraphicsSequenceFilter sequenceFilter = manager.Initializers.SequenceFilter.Initialize();

sequenceFilter.Add((IAgStkGraphicsRasterFilter)manager.Initializers.BrightnessFilter.InitializeWithAdjustment(.1));

sequenceFilter.Add((IAgStkGraphicsRasterFilter)manager.Initializers.ContrastFilter.InitializeWithAdjustment(.2));

sequenceFilter.Add((IAgStkGraphicsRasterFilter)manager.Initializers.GammaCorrectionFilter.InitializeWithGamma(.9));

image.ApplyInPlace((IAgStkGraphicsRasterFilter)sequenceFilter);


IAgStkGraphicsRendererTexture2D texture = manager.Textures.FromRaster(image);


//

// Display the image using a screen overlay

//

IAgStkGraphicsTextureScreenOverlay overlay = manager.Initializers.TextureScreenOverlay.Initialize();

((IAgStkGraphicsOverlay)overlay).Width = 0.2;

((IAgStkGraphicsOverlay)overlay).WidthUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Height = 0.2;

((IAgStkGraphicsOverlay)overlay).HeightUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginCenterRight;

overlay.Texture = texture;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Adjust the color levels of an image

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: The image file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;

//

// The URI can be a file path, http, https, or ftp location

//

IAgStkGraphicsRaster image = manager.Initializers.Raster.InitializeWithStringUri(

    imageFile);


//

// Adjust the color levels of the image

//

IAgStkGraphicsLevelsFilter levelsFilter = manager.Initializers.LevelsFilter.Initialize();

levelsFilter.SetLevelAdjustment(AgEStkGraphicsRasterBand.eStkGraphicsRasterBandBlue, -255);

levelsFilter.SetLevelAdjustment(AgEStkGraphicsRasterBand.eStkGraphicsRasterBandGreen, -255);

image.ApplyInPlace((IAgStkGraphicsRasterFilter)levelsFilter);


IAgStkGraphicsRendererTexture2D texture = manager.Textures.FromRaster(image);


//

// Display the image using a screen overlay

//

IAgStkGraphicsTextureScreenOverlay overlay = manager.Initializers.TextureScreenOverlay.Initialize();

((IAgStkGraphicsOverlay)overlay).Width = 0.2;

((IAgStkGraphicsOverlay)overlay).WidthUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Height = 0.2;

((IAgStkGraphicsOverlay)overlay).HeightUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginBottomRight;

overlay.Texture = texture;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Blur an image with a convolution matrix

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: The image file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;

//

// The URI can be a file path, http, https, or ftp location

//

IAgStkGraphicsRaster image = manager.Initializers.Raster.InitializeWithStringUri(

    imageFile);


//

// Set convolution matrix to blur

//

Array kernel = new object[]

    {

        1, 1, 1,

        1, 1, 1,

        1, 1, 1

    };

IAgStkGraphicsConvolutionFilter convolutionMatrix = manager.Initializers.ConvolutionFilter.InitializeWithKernelAndDivisor(ref kernel, 9.0);

image.ApplyInPlace((IAgStkGraphicsRasterFilter)convolutionMatrix);


IAgStkGraphicsRendererTexture2D texture = manager.Textures.FromRaster(image);


//

// Display the image using a screen overlay

//

IAgStkGraphicsTextureScreenOverlay overlay = manager.Initializers.TextureScreenOverlay.Initialize();

((IAgStkGraphicsOverlay)overlay).Width = 0.2;

((IAgStkGraphicsOverlay)overlay).WidthUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Height = 0.2;

((IAgStkGraphicsOverlay)overlay).HeightUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginBottomLeft;

overlay.Texture = texture;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Extract the alpha component from an image

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: The image file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;

//

// The URI can be a file path, http, https, or ftp location

//

IAgStkGraphicsRaster image = manager.Initializers.Raster.InitializeWithStringUri(

    imageFile);


//

// Extract the alpha channel from the image

//

IAgStkGraphicsBandExtractFilter channelExtract = manager.Initializers.BandExtractFilter.InitializeWithBand(AgEStkGraphicsRasterBand.eStkGraphicsRasterBandAlpha);

image.ApplyInPlace((IAgStkGraphicsRasterFilter)channelExtract);


IAgStkGraphicsRendererTexture2D texture = manager.Textures.FromRaster(image);


//

// Display the image using a screen overlay

//

IAgStkGraphicsTextureScreenOverlay overlay = manager.Initializers.TextureScreenOverlay.Initialize();

((IAgStkGraphicsOverlay)overlay).Width = 0.2;

((IAgStkGraphicsOverlay)overlay).WidthUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Height = 0.2;

((IAgStkGraphicsOverlay)overlay).HeightUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginTopRight;

overlay.Texture = texture;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Flip an image

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: The image file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;

//

// The URI can be a file path, http, https, or ftp location

//

IAgStkGraphicsRaster image = manager.Initializers.Raster.InitializeWithStringUri(

    imageFile);

image.Flip(AgEStkGraphicsFlipAxis.eStkGraphicsFlipAxisVertical);


IAgStkGraphicsRendererTexture2D texture = manager.Textures.FromRaster(image);


IAgStkGraphicsTextureScreenOverlay overlay = manager.Initializers.TextureScreenOverlay.Initialize();

((IAgStkGraphicsOverlay)overlay).Size = new object[]

{

    0.2, 0.2,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction

};

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginTopLeft;

overlay.Texture = texture;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Load and display a raster stream

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: Image file to use for the raster


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;


//

// Create the RasterStream from the plugin

//

IAgStkGraphicsProjectionRasterStreamPluginActivator activator =

    manager.Initializers.ProjectionRasterStreamPluginActivator.Initialize();

IAgStkGraphicsProjectionRasterStreamPluginProxy proxy =

    activator.CreateFromDisplayName("ProjectionRasterStreamPlugin.CSharp");


//

// Use reflection to set the plugin's properties

//

Type plugin = proxy.RealPluginObject.GetType();

plugin.GetProperty("RasterPath").SetValue(proxy.RealPluginObject, imageFile, null);


IAgStkGraphicsRasterStream rasterStream = proxy.RasterStream;

rasterStream.UpdateDelta = 0.01667;


//

// Creates the texture screen overlay to display the raster

//

IAgStkGraphicsRendererTexture2D texture = manager.Textures.FromRaster((IAgStkGraphicsRaster)rasterStream);

IAgStkGraphicsTextureScreenOverlay overlay =

    manager.Initializers.TextureScreenOverlay.InitializeWithXYWidthHeight(0, 0,

    texture.Template.Width, texture.Template.Height);

overlay.Texture = texture;

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginCenterLeft;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Swizzle an image's components

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: The image file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;

//

// The URI can be a file path, http, https, or ftp location

//

IAgStkGraphicsRaster image = manager.Initializers.Raster.InitializeWithStringUri(

    imageFile);


//

// Swizzle RGBA to BGRA

//

IAgStkGraphicsBandOrderFilter channelOrder = manager.Initializers.BandOrderFilter.InitializeWithOrder(AgEStkGraphicsRasterFormat.eStkGraphicsRasterFormatBgra);

image.ApplyInPlace((IAgStkGraphicsRasterFilter)channelOrder);


IAgStkGraphicsRendererTexture2D texture = manager.Textures.FromRaster(image);


//

// Display the image using a screen overlay

//

IAgStkGraphicsTextureScreenOverlay overlay = manager.Initializers.TextureScreenOverlay.Initialize();

((IAgStkGraphicsOverlay)overlay).Width = 0.2;

((IAgStkGraphicsOverlay)overlay).WidthUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Height = 0.2;

((IAgStkGraphicsOverlay)overlay).HeightUnit = AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitFraction;

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginTopCenter;

overlay.Texture = texture;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Shows the format of the Extent and SubExtent parameters when writing using a Jpeg 2000 Writer.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// String imagePath: Path to the image to write

// String saveFile: Path to the output file


Array extent = new object[]

{

    -1,

    -1,

    1,

    1

};


Array subExtent = new object[]

{

    -0.5,

    -0.5,

    0.5,

    0.5

};


sceneManager.Initializers.Jpeg2000Writer.WriteExtentAndSubExtentString(

    imagePath,

    ref extent,

    ref subExtent,

    AgEStkGraphicsJpeg2000CompressionProfile.eStkGraphicsJpeg2000CompressionProfileDefault,

    1,

    saveFile,

    true);

Shows the format of the model's Position property.

[C#] Copy Code

// IAgStkGraphicsModelPrimitive model: A model primitive


Array position = new object[]

{

    31378.1,

    0,

    0

};


model.Position = position;

Shows the format of the Position parameter when updating a model.

[C#] Copy Code

// IAgStkGraphicsModelPrimitive model: A model primitive


Array position = new object[]

{

    39.88,

    -75.25,

    0

};


model.SetPositionCartographic(

    "Earth",

    ref position);

Shows the format of the overlay's MaximumSize property.

[C#] Copy Code

// IAgStkGraphicsOverlay overlay: A valid overlay object.


Array maximumSize = new object[]

{

    500,

    500,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


overlay.MaximumSize = maximumSize;

Shows the format of the overlay's MinimumSize property.

[C#] Copy Code

// IAgStkGraphicsOverlay overlay: A valid overlay object.


Array minimumSize = new object[]

{

    5,

    5,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


overlay.MinimumSize = minimumSize;

Shows the format of the overlay's Padding property.

[C#] Copy Code

// IAgStkGraphicsOverlay overlay: A valid overlay object.


Array padding = new object[]

{

    10,

    10,

    10,

    10

};


overlay.Padding = padding;

Shows the format of the overlay's PinningPosition property.

[C#] Copy Code

// IAgStkGraphicsOverlay overlay: A valid overlay object.


Array pinningPosition = new object[]

{

    5,

    5,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


overlay.PinningPosition = pinningPosition;

Shows the format of the overlay's Position property.

[C#] Copy Code

// IAgStkGraphicsOverlay overlay: A valid overlay object.


Array position = new object[]

{

    50,

    50,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


overlay.Position = position;

Shows the format of the overlay's RotationPoint property.

[C#] Copy Code

// IAgStkGraphicsOverlay overlay: A valid overlay object.


Array rotationPoint = new object[]

{

    false,

    AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginCenter,

    true,

    0.0,

    0.0,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


overlay.RotationPoint = rotationPoint;

Shows the format of the overlay's Size property.

[C#] Copy Code

// IAgStkGraphicsOverlay overlay: A valid overlay object.


Array size = new object[]

{

    300,

    300,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


overlay.Size = size;

Shows the format of the path point's Position property.

[C#] Copy Code

// IAgStkGraphicsPathPoint path: A valid path point object


Array position = new object[]

{

    1089235,

    -4800930,

    4046386

};


path.Position = position;

Shows the format of the Position parameter when creating a path point.

[C#] Copy Code

// AgStkObjectRoot root: STK Object Model root

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array position = new object[]

{

    1089235,

    -4800930,

    4046386

};


IAgStkGraphicsPathPoint path = sceneManager.Initializers.PathPoint.InitializeWithDateAndPosition(

    root.ConversionUtility.NewDate("UTCG", ((IAgScenario)root.CurrentScenario).StartTime.ToString()),

    ref position);

Change a model's color on mouse over

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// IAgStkGraphicsPrimitive m_SelectedModel: The previously selected model


//

// Get a collection of picked objects under the mouse location.

// The collection is sorted with the closest object at index zero.

//

IAgStkGraphicsPickResultCollection collection = scene.Pick(mouseX, mouseY);

if (collection.Count != 0)

{

    IAgStkGraphicsObjectCollection objects = collection[0].Objects;

    IAgStkGraphicsCompositePrimitive composite = objects[0] as IAgStkGraphicsCompositePrimitive;


    //

    // Was a model in our composite picked?

    //

    if (composite == m_Models)

    {

        IAgStkGraphicsPrimitive model = objects[1] as IAgStkGraphicsPrimitive;


        //

        // Selected Model

        //

        model.Color = Color.Cyan;


        if (model != m_SelectedModel)

        {

            //

            // Unselect previous model

            //

            if (m_SelectedModel != null)

            {

                m_SelectedModel.Color = Color.Red;

            }

            m_SelectedModel = model;

            scene.Render();

        }

        return;

   }

}


//

// Unselect previous model

//

if (m_SelectedModel != null)

{

    m_SelectedModel.Color = Color.Red;

    m_SelectedModel = null;

    scene.Render();

}

Change model colors within a rectangular region

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// List<IAgStkGraphicsModelPrimitive> SelectedModels: The previously selected models


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

//

// Get a collection of picked objects in a 100 by 100 rectangular region.

// The collection is sorted with the closest object at index zero.

//

List<IAgStkGraphicsModelPrimitive> newModels = new List<IAgStkGraphicsModelPrimitive>();

IAgStkGraphicsPickResultCollection collection = scene.PickRectangular(mouseX - 50, mouseY + 50, mouseX + 50, mouseY - 50);

foreach (IAgStkGraphicsPickResult pickResult in collection)

{

    IAgStkGraphicsObjectCollection objects = pickResult.Objects;

    IAgStkGraphicsCompositePrimitive composite = objects[0] as IAgStkGraphicsCompositePrimitive;


    //

    // Was a model in our composite picked?

    //

    if (composite == m_Models)

    {

        IAgStkGraphicsModelPrimitive model = objects[1] as IAgStkGraphicsModelPrimitive;


        //

        // Selected Model

        //

        ((IAgStkGraphicsPrimitive)model).Color = Color.Cyan;

        newModels.Add(model);

    }

}

//

// Reset color of models that were previous selected but were not in this pick.

//

foreach (IAgStkGraphicsModelPrimitive selectedModel in SelectedModels)

{

    if (!newModels.Contains(selectedModel))

    {

        ((IAgStkGraphicsPrimitive)selectedModel).Color = Color.Red;

    }

}

SelectedModels = newModels;


manager.Render();

Zoom to a model on double click

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsPrimitive selectedModel = null;

//

// Get a collection of picked objects under the mouse location.

// The collection is sorted with the closest object at index zero.

//

IAgStkGraphicsPickResultCollection collection = scene.Pick(mouseX, mouseY);

if (collection.Count != 0)

{

    IAgStkGraphicsObjectCollection objects = collection[0].Objects;

    IAgStkGraphicsCompositePrimitive composite = objects[0] as IAgStkGraphicsCompositePrimitive;


    //

    // Was a model in our composite picked?

    //

    if (composite == m_Models)

    {

        selectedModel = objects[1] as IAgStkGraphicsPrimitive;

    }

}

Zoom to a particular marker in a batch

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String markerFile: The file to use for the markers

// IList<Array> markerPositions: A list of the marker positions


Array selectedMarkerCartesianPosition = null;

//

// Get a collection of picked objects under the mouse location.

// The collection is sorted with the closest object at index zero.

//

IAgStkGraphicsPickResultCollection collection = scene.Pick(mouseX, mouseY);

if (collection.Count != 0)

{

    IAgStkGraphicsObjectCollection objects = collection[0].Objects;

    IAgStkGraphicsMarkerBatchPrimitive batchPrimitive = objects[0] as IAgStkGraphicsMarkerBatchPrimitive;


    //

    // Was a marker in our marker batch picked?

    //

    if (batchPrimitive == m_MarkerBatch)

    {

        //

        // Get the index of the particular marker we picked

        //

        IAgStkGraphicsBatchPrimitiveIndex markerIndex = objects[1] as IAgStkGraphicsBatchPrimitiveIndex;


        //

        // Get the position of the particular marker we picked

        //

        Array markerCartographic = markerPositions[markerIndex.Index];


        IAgPosition markerPosition = root.ConversionUtility.NewPositionOnEarth();

        markerPosition.AssignPlanetodetic(

            (double)markerCartographic.GetValue(0),

            (double)markerCartographic.GetValue(1),

            (double)markerCartographic.GetValue(2));


        double x, y, z;

        markerPosition.QueryCartesian(out x, out y, out z);


        selectedMarkerCartesianPosition = new object[] { x, y, z };

    }

}



IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IList<Array> positions = new List<Array>();

positions.Add(new object[] {39.88, -75.25, 3000.0 });

positions.Add(new object[] {38.85, -77.04, 3000.0 });

positions.Add(new object[] {38.85, -77.04, 0.0 });

positions.Add(new object[] {29.98, -90.25, 0.0 });

positions.Add(new object[] {37.37, -121.92, 0.0 });


Array positionsArray = Array.CreateInstance(typeof(object), positions.Count * 3);

for (int i = 0; i < positions.Count; ++i)

{

    Array position = positions[i];

    position.CopyTo(positionsArray, i * 3);

}


IAgStkGraphicsMarkerBatchPrimitive markerBatch = manager.Initializers.MarkerBatchPrimitive.Initialize();

markerBatch.Texture = manager.Textures.LoadFromStringUri(

    markerFile);

markerBatch.SetCartographic("Earth", ref positionsArray);


// Save the positions of the markers for use in the pick event

markerPositions = positions;


// Enable per item picking

markerBatch.PerItemPickingEnabled = true;


manager.Primitives.Add((IAgStkGraphicsPrimitive)markerBatch);

Shows the format of the Positions parameter when interpolating positions.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


IAgStkGraphicsPositionInterpolator interpolator = sceneManager.Initializers.GreatArcInterpolator.InitializeWithCentralBody("Earth") as IAgStkGraphicsPositionInterpolator;


Array positions = new object[]

{

    39.88, -75.25, 0,

    38.85, -77.04, 0,

};


Array results = interpolator.Interpolate(ref positions);

Create layers of primitives

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String modelFile: Location of the model file

// String markerFile: The file to use for the marker batch


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


Random r = new Random();

const int modelCount = 25;


Array positions = Array.CreateInstance(typeof(object), modelCount * 3);


//

// Create the models

//

IAgStkGraphicsCompositePrimitive models = manager.Initializers.CompositePrimitive.Initialize();


for (int i = 0; i < modelCount; ++i)

{

    double latitude = 35 + 1.5 * r.NextDouble();

    double longitude = -(80 + 1.5 * r.NextDouble());

    double altitude = 0;

    Array position = new object[3]{latitude, longitude, altitude};


    positions.SetValue(latitude, 3 * i);

    positions.SetValue(longitude, (3 * i) + 1);

    positions.SetValue(altitude, (3 * i) + 2);


    IAgStkGraphicsModelPrimitive model = manager.Initializers.ModelPrimitive.InitializeWithStringUri(modelFile);

    model.SetPositionCartographic("Earth", ref position);

    model.Scale = Math.Pow(10, 2);

    models.Add((IAgStkGraphicsPrimitive)model);

}


//

// Create the markers

//

IAgStkGraphicsMarkerBatchPrimitive markers = manager.Initializers.MarkerBatchPrimitive.Initialize();

markers.RenderPass = AgEStkGraphicsMarkerBatchRenderPass.eStkGraphicsMarkerBatchRenderPassTranslucent;


markers.Texture = manager.Textures.LoadFromStringUri(markerFile);

markers.SetCartographic("Earth", ref positions);


//

// Create the points

//

IAgStkGraphicsPointBatchPrimitive points = manager.Initializers.PointBatchPrimitive.Initialize();

points.PixelSize = 5;

Array colors = Array.CreateInstance(typeof(object), modelCount);

for (int i = 0; i < colors.Length; i++)

    colors.SetValue(Color.Orange.ToArgb(), i);

points.SetCartographicWithColorsAndRenderPass("Earth", ref positions, ref colors, AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);


//

// Set the display Conditions

//

IAgStkGraphicsAltitudeDisplayCondition near = manager.Initializers.AltitudeDisplayCondition.InitializeWithAltitudes(0, 500000);

((IAgStkGraphicsPrimitive)models).DisplayCondition = (IAgStkGraphicsDisplayCondition)near;


IAgStkGraphicsAltitudeDisplayCondition medium = manager.Initializers.AltitudeDisplayCondition.InitializeWithAltitudes(500000, 2000000);

((IAgStkGraphicsPrimitive)markers).DisplayCondition = (IAgStkGraphicsDisplayCondition)medium;


IAgStkGraphicsAltitudeDisplayCondition far = manager.Initializers.AltitudeDisplayCondition.InitializeWithAltitudes(2000000, 4000000);

((IAgStkGraphicsPrimitive)points).DisplayCondition = (IAgStkGraphicsDisplayCondition)far;


manager.Primitives.Add((IAgStkGraphicsPrimitive)models);

manager.Primitives.Add((IAgStkGraphicsPrimitive)markers);

manager.Primitives.Add((IAgStkGraphicsPrimitive)points);

Z-order primitives on the surface

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// Array pennsylvaniaPositions: Pennsylvania positions

// Array areaCode610Positions: Area Code 610 positions

// Array areaCode215Positions: Area Code 215 positions

// Array schuylkillPositions: Schuylkill positions


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsTriangleMeshPrimitive pennsylvania = manager.Initializers.TriangleMeshPrimitive.Initialize();

pennsylvania.SetTriangulator((IAgStkGraphicsTriangulatorResult)manager.Initializers.SurfacePolygonTriangulator.Compute(

    "Earth", ref pennsylvaniaPositions));

((IAgStkGraphicsPrimitive)pennsylvania).Color = Color.Yellow;


IAgStkGraphicsTriangleMeshPrimitive areaCode610 = manager.Initializers.TriangleMeshPrimitive.Initialize();

areaCode610.SetTriangulator((IAgStkGraphicsTriangulatorResult)manager.Initializers.SurfacePolygonTriangulator.Compute(

    "Earth", ref areaCode610Positions));

((IAgStkGraphicsPrimitive)areaCode610).Color = Color.DarkRed;


IAgStkGraphicsTriangleMeshPrimitive areaCode215 = manager.Initializers.TriangleMeshPrimitive.Initialize();

areaCode215.SetTriangulator((IAgStkGraphicsTriangulatorResult)manager.Initializers.SurfacePolygonTriangulator.Compute(

    "Earth", ref areaCode215Positions));

((IAgStkGraphicsPrimitive)areaCode215).Color = Color.Green;


IAgStkGraphicsPolylinePrimitive schuylkillRiver = manager.Initializers.PolylinePrimitive.Initialize();

schuylkillRiver.Set(ref schuylkillPositions);

((IAgStkGraphicsPrimitive)schuylkillRiver).Color = Color.Blue;

schuylkillRiver.Width = 2;


IAgStkGraphicsCompositePrimitive composite = manager.Initializers.CompositePrimitive.Initialize();

composite.Add((IAgStkGraphicsPrimitive)pennsylvania);

composite.Add((IAgStkGraphicsPrimitive)areaCode610);

composite.Add((IAgStkGraphicsPrimitive)areaCode215);

composite.Add((IAgStkGraphicsPrimitive)schuylkillRiver);


manager.Primitives.Add((IAgStkGraphicsPrimitive)composite);

Draw a set of markers

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String markerImageFile: The image file to use for the markers


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


Array positions = new object[]

{

    39.88, -75.25, 0,    // Philadelphia

    38.85, -77.04, 0, // Washington, D.C.

    29.98, -90.25, 0, // New Orleans

    37.37, -121.92, 0    // San Jose

};


IAgStkGraphicsMarkerBatchPrimitive markerBatch = manager.Initializers.MarkerBatchPrimitive.Initialize();

markerBatch.Texture = manager.Textures.LoadFromStringUri(

    markerImageFile);

markerBatch.SetCartographic("Earth", ref positions);


manager.Primitives.Add((IAgStkGraphicsPrimitive)markerBatch);

Shows the format of the Colors parameter when setting per marker colors.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetColors(ref colors);

Shows the format of the Colors, Positions and Indices parameters when updating a marker batch primitive with cartographic positions.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// IAgStkGraphicsMarkerBatchPrimitive markerBatch: A marker batch primitive


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetColors(ref colors);


Array positions = new object[]

{

    39.88, -75.25, 0,

    38.85, -77.04, 0,

    29.98, -90.25, 0,

    37.37, -121.92, 0

};


Array indices = new object[]

{

    0,

    1,

    2,

    3

};


markerBatch.SetPartialCartographicWithOptionalParametersIndicesOrderAndRenderPass(

    "Earth",

    ref positions,

    parameters,

    ref indices,

    AgEStkGraphicsIndicesOrderHint.eStkGraphicsIndicesOrderHintSortedAscending,

    AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);

Shows the format of the Colors, Positions and Indices parameters when updating a marker batch primitive.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// IAgStkGraphicsMarkerBatchPrimitive markerBatch: A marker batch primitive


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetColors(ref colors);


Array positions = new object[]

{

    1247.87, -4739.74, 4067.77,

    1115.48, -4847.09, 3979.36,

    -24.12, -5529.31, 3168.45,

    -2683.42, -4307.74, 3850.11

};


Array indices = new object[]

{

    0,

    1,

    2,

    3

};


markerBatch.SetPartialWithOptionalParametersIndicesOrderAndRenderPass(

    ref positions,

    parameters,

    ref indices,

    AgEStkGraphicsIndicesOrderHint.eStkGraphicsIndicesOrderHintSortedAscending,

    AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);

Shows the format of the EyeOffsets parameter when setting per marker eye offsets.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array eyeoffset = new object[]

{

    2, 3, 4,

    2, 3, 4

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetEyeOffsets(ref eyeoffset);

Shows the format of the marker batch's EyeOffset property.

[C#] Copy Code

// IAgStkGraphicsMarkerBatchPrimitive markerBatch: A marker batch primitive


Array eyeoffset = new object[]

{

    2,

    3,

    4

};


markerBatch.EyeOffset = eyeoffset;

Shows the format of the marker batch's PixelOffset property.

[C#] Copy Code

// IAgStkGraphicsMarkerBatchPrimitive markerBatch: A marker batch primitive


Array pixelOffset = new object[]

{

    1,

    2

};


markerBatch.PixelOffset = pixelOffset;

Shows the format of the marker batch's Size property.

[C#] Copy Code

// IAgStkGraphicsMarkerBatchPrimitive markerBatch: A marker batch primitive


Array size = new object[]

{

    256,

    128

};


markerBatch.Size = size;

Shows the format of the marker batch's TextureCoordinate property.

[C#] Copy Code

// IAgStkGraphicsMarkerBatchPrimitive markerBatch: A marker batch primitive


Array coordinates = new object[]

{

    0,

    0,

    1,

    1

};


markerBatch.TextureCoordinate = coordinates;

Shows the format of the Origins parameter when setting per marker origins.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array origins = new object[]

{

    AgEStkGraphicsOrigin.eStkGraphicsOriginCenter,

    AgEStkGraphicsOrigin.eStkGraphicsOriginBottomLeft,

    AgEStkGraphicsOrigin.eStkGraphicsOriginBottomRight,

    AgEStkGraphicsOrigin.eStkGraphicsOriginTopLeft

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetOrigins(ref origins);

Shows the format of the PixelOffsets parameter when setting per marker pixel offsets.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array pixelOffset = new object[]

{

    1, 2,

    2, 1

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetPixelOffsets(ref pixelOffset);

Shows the format of the RotationAngles parameter when setting per marker rotations.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array rotations = new object[]

{

    15,

    30,

    45,

    60

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetRotations(ref rotations);

Shows the format of the Sizes parameter when setting per marker sizes.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array size = new object[]

{

    256,

    128,

    128,

    256

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetSizes(ref size);

Shows the format of the TextureCoordinates parameter when setting per marker texture coordinates.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array coordinates = new object[]

{

    0, 0, 1, 1,

    1, 1, 0, 0

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetTextureCoordinates(ref coordinates);

Shows the format of the Textures parameter when setting per marker textures.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// String texturePath1: Path to the first texture file

// String texturePath2: Path to the second texture file

// String texturePath3: Path to the third texture file

// String texturePath4: Path to the fourth texture file


Array textures = new object[]

{

    sceneManager.Textures.LoadFromStringUri(texturePath1),

    sceneManager.Textures.LoadFromStringUri(texturePath2),

    sceneManager.Textures.LoadFromStringUri(texturePath3),

    sceneManager.Textures.LoadFromStringUri(texturePath4)

};


IAgStkGraphicsMarkerBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.MarkerBatchPrimitiveOptionalParameters.Initialize();

parameters.SetTextures(ref textures);

Draw a Collada model with user defined lighting

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String modelFile: The model file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsModelPrimitive model = manager.Initializers.ModelPrimitive.InitializeWithStringUri(

    modelFile);


Array position = new object[] { 39.88, -75.25, 500000.0 };

model.SetPositionCartographic("Earth", ref position);

model.Scale = Math.Pow(10, 2);


manager.Primitives.Add((IAgStkGraphicsPrimitive)model);

Draw a Collada or MDL model

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String modelFile: The model file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsModelPrimitive model = manager.Initializers.ModelPrimitive.InitializeWithStringUri(

    modelFile);


Array position = new object[] { 39.88, -75.25, 5000.0 };

model.SetPositionCartographic("Earth", ref position);

model.Scale = Math.Pow(10, 2);


manager.Primitives.Add((IAgStkGraphicsPrimitive)model);

Draw a dynamically textured Collada model

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String modelFile: The model file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsModelPrimitive model = manager.Initializers.ModelPrimitive.InitializeWithStringUri(

    modelFile);


Array position = new object[] { 49.88, -77.25, 5000.0 };

model.SetPositionCartographic("Earth", ref position);

model.Scale = Math.Pow(10, 2);


manager.Primitives.Add((IAgStkGraphicsPrimitive)model);


//  hellfireflame.anc

//

//  <?xml version = "1.0" standalone = "yes"?>

//  <ancillary_model_data version = "1.0">

//       <video_textures>

//           <video_texture image_id = "smoketex_tga" init_from = "smoke.avi" video_loop="true" video_framerate="60" />

//           <video_texture image_id = "flametex_tga" init_from = "flame.mov" video_loop="true" video_framerate="60" />

//      </video_textures>

//  </ancillary_model_data>

Draw a model with moving articulations

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String modelFile: The model file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

//

// Create the model

//

IAgStkGraphicsModelPrimitive model = manager.Initializers.ModelPrimitive.InitializeWithStringUri(

    modelFile);


Array position = new object[3] { 36, -116.75, 25000.0 };

model.SetPositionCartographic("Earth", ref position);


//

// Rotate the model to be oriented correctly

//

model.Articulations.GetByName("Commuter").GetByName("Roll").CurrentValue = 4.084070562;

model.Articulations.GetByName("Commuter").GetByName("Yaw").CurrentValue = -0.436332325;


manager.Primitives.Add((IAgStkGraphicsPrimitive)model);



internal void TimeChanged(double TimeEpSec)

{

    //

    // Rotate the propellors every time the animation updates

    //

    if (m_Model != null)

    {

        double TwoPI = 2 * Math.PI;

        ((IAgStkGraphicsModelPrimitive)m_Model).Articulations.GetByName("props").GetByName("Spin").CurrentValue = TimeEpSec % TwoPI;

    }

}

Orient a model

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String modelFile: The model file

// IAgCrdnSystem referenceFrame: A reference frame for the model


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsModelPrimitive model = manager.Initializers.ModelPrimitive.InitializeWithStringUri(

    modelFile);

((IAgStkGraphicsPrimitive)model).ReferenceFrame = referenceFrame;  // Model is oriented using east-north-up axes.  Use model.Orientation for addition rotation.

Array zero = new object[] { 0, 0, 0 }; // Origin of reference frame

model.Position = zero;

model.Scale = Math.Pow(10, 1.5);


manager.Primitives.Add((IAgStkGraphicsPrimitive)model);

Shows the format of the Positions parameter when adding points to a path primitive.

[C#] Copy Code

// IAgStkGraphicsPathPrimitive path: A path primitive


Array positions = new object[]

{

    0, 0, 0,

    1, 1, 1,

    2, 2, 2,

    3, 3, 3,

    4, 4, 4

};


path.AddRangeToFront(ref positions);

Draw a set of points

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


Array positions = new object[]

{

    39.88, -75.25, 0,    // Philadelphia

    38.85, -77.04, 0, // Washington, D.C.

    29.98, -90.25, 0, // New Orleans

    37.37, -121.92, 0    // San Jose

};


IAgStkGraphicsPointBatchPrimitive pointBatch = manager.Initializers.PointBatchPrimitive.Initialize();

pointBatch.SetCartographic("Earth", ref positions);

pointBatch.PixelSize = 5;

((IAgStkGraphicsPrimitive)pointBatch).Color = Color.White;

pointBatch.DisplayOutline = true;

pointBatch.OutlineWidth = 2;

pointBatch.OutlineColor = Color.Red;


manager.Primitives.Add((IAgStkGraphicsPrimitive)pointBatch);

Draw a set of uniquely colored points

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array positions = new object[]

{

    37.62, -122.38, 0.0,    // San Francisco

    38.52, -121.50, 0.0,    // Sacramento

    33.93, -118.40, 0.0,    // Los Angeles

    32.82, -117.13, 0.0     // San Diego

};


Array colors = new object[]

{

    (uint)Color.Red.ToArgb(),

    (uint)Color.Orange.ToArgb(),

    (uint)Color.Blue.ToArgb(),

    (uint)Color.White.ToArgb()

};


IAgStkGraphicsPointBatchPrimitive pointBatch = manager.Initializers.PointBatchPrimitive.Initialize();

pointBatch.SetCartographicWithColors("Earth", ref positions, ref colors);

pointBatch.PixelSize = 8;


manager.Primitives.Add((IAgStkGraphicsPrimitive)pointBatch);

Shows the format of the Positions, Colors and Indices parameters when updating a point batch with cartographic positions.

[C#] Copy Code

// IAgStkGraphicsPointBatchPrimitive pointBatch: A point batch primitive


Array positions = new object[]

{

    39.88, -75.25, 0,

    38.85, -77.04, 0,

    29.98, -90.25, 0,

    37.37, -121.92, 0

};


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


Array indices = new object[]

{

    0,

    1,

    2,

    3

};


pointBatch.SetPartialCartographicWithColorsIndicesOrderAndRenderPass(

    "Earth",

    ref positions,

    ref colors,

    ref indices,

    AgEStkGraphicsIndicesOrderHint.eStkGraphicsIndicesOrderHintSortedAscending,

    AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);

Shows the format of the Positions, Colors and Indices parameters when updating a point batch.

[C#] Copy Code

// IAgStkGraphicsPointBatchPrimitive pointBatch: A point batch primitive


Array positions = new object[]

{

    1247.87, -4739.74, 4067.77,

    1115.48, -4847.09, 3979.36,

    -24.12, -5529.31, 3168.45,

    -2683.42, -4307.74, 3850.11

};


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


Array indices = new object[]

{

    0,

    1,

    2,

    3

};


pointBatch.SetPartialWithColorsIndicesOrderAndRenderPass(

    ref positions,

    ref colors,

    ref indices,

    AgEStkGraphicsIndicesOrderHint.eStkGraphicsIndicesOrderHintSortedAscending,

    AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);

Draw a great arc on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array washingtonDC = new object[]

{

    38.85,

    -77.04,

    0.0

};

Array newOrleans = new object[]

{

    29.98,

    -90.25,

    0.0

};


Array positions = new object[6];

washingtonDC.CopyTo(positions, 0);

newOrleans.CopyTo(positions, 3);


IAgStkGraphicsPositionInterpolator interpolator = manager.Initializers.GreatArcInterpolator.Initialize() as IAgStkGraphicsPositionInterpolator;

IAgStkGraphicsPolylinePrimitive line = manager.Initializers.PolylinePrimitive.InitializeWithInterpolator(interpolator);

line.SetCartographic("Earth", ref positions);


manager.Primitives.Add((IAgStkGraphicsPrimitive)line);

Draw a line between two points

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array philadelphia = new object[]

{

    39.88,

    -75.25,

    3000.0

};

Array washingtonDC = new object[]

{

    38.85,

    -77.04,

    3000.0

};


Array positions = new object[6];

philadelphia.CopyTo(positions, 0);

washingtonDC.CopyTo(positions, 3);


IAgStkGraphicsPolylinePrimitive line = manager.Initializers.PolylinePrimitive.Initialize();

line.SetCartographic("Earth", ref positions);

manager.Primitives.Add((IAgStkGraphicsPrimitive)line);

Draw a rhumb line on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array newOrleans = new object[]

{

    29.98,

    -90.25,

    0.0

};

Array sanJose = new object[]

{

    37.37,

    -121.92,

    0.0

};


Array positions = new object[6];

newOrleans.CopyTo(positions, 0);

sanJose.CopyTo(positions, 3);


IAgStkGraphicsPositionInterpolator interpolator = manager.Initializers.RhumbLineInterpolator.Initialize() as IAgStkGraphicsPositionInterpolator;

IAgStkGraphicsPolylinePrimitive line = manager.Initializers.PolylinePrimitive.InitializeWithInterpolator(interpolator);

line.SetCartographic("Earth", ref positions);

manager.Primitives.Add((IAgStkGraphicsPrimitive)line);

Draw a STK area target outline on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// Array positions: The area target positions


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsPolylinePrimitive line = manager.Initializers.PolylinePrimitive.Initialize();

line.Set(ref positions);

line.Width = 2;

((IAgStkGraphicsPrimitive)line).Color = Color.Yellow;

line.DisplayOutline = true;

line.OutlineWidth = 2;

line.OutlineColor = Color.Black;


manager.Primitives.Add((IAgStkGraphicsPrimitive)line);

Draw the outline of a circle on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array center = new object[] { 39.88, -75.25, 0.0 }; // Philadelphia


IAgStkGraphicsSurfaceShapesResult shape = manager.Initializers.SurfaceShapes.ComputeCircleCartographic("Earth", ref center, 10000);

Array positions = shape.Positions;


IAgStkGraphicsPolylinePrimitive line = manager.Initializers.PolylinePrimitive.InitializeWithType(shape.PolylineType);

line.Set(ref positions);

line.Width = 2;

((IAgStkGraphicsPrimitive)line).Color = Color.White;


manager.Primitives.Add((IAgStkGraphicsPrimitive)line);

Draw the outline of an ellipse on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array center = new object[] { 38.85, -77.04, 3000.0 }; // Washington, DC


IAgStkGraphicsSurfaceShapesResult shape = manager.Initializers.SurfaceShapes.ComputeEllipseCartographic(

    "Earth", ref center, 45000, 30000, 45);

Array positions = shape.Positions;


IAgStkGraphicsPolylinePrimitive line = manager.Initializers.PolylinePrimitive.InitializeWithType(shape.PolylineType);

line.Set(ref positions);

((IAgStkGraphicsPrimitive)line).Color = Color.Cyan;


manager.Primitives.Add((IAgStkGraphicsPrimitive)line);

Shows the format of the Positions parameter when updating a polyline primitive with cartographic positions.

[C#] Copy Code

// IAgStkGraphicsPolylinePrimitive polyline: A polyline primitive


Array positions = new object[]

{

    39.88, -75.25, 0,

    38.85, -77.04, 0,

    29.98, -90.25, 0,

    37.37, -121.92, 0

};


polyline.SetSubsetCartographic(

    "Earth",

    ref positions,

    1,

    2);

Shows the format of the Positions parameter when updating a polyline primitive.

[C#] Copy Code

// IAgStkGraphicsPolylinePrimitive polyline: A polyline primitive


Array positions = new object[]

{

    1247.87, -4739.74, 4067.77,

    1115.48, -4847.09, 3979.36,

    -24.12, -5529.31, 3168.45,

    -2683.42, -4307.74, 3850.11

};


polyline.SetSubset(

    ref positions,

    1,

    2);

Shows the format of the Positions, Colors and Indices parameters when updating a polyline primitive with cartographic positions.

[C#] Copy Code

// IAgStkGraphicsPolylinePrimitive polyline: A polyline primitive


Array positions = new object[]

{

    39.88, -75.25, 0,

    38.85, -77.04, 0,

    29.98, -90.25, 0,

    37.37, -121.92, 0

};


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


Array indices = new object[]

{

    0,

    1,

    2,

    3

};


polyline.SetPartialCartographicWithColorsIndicesOrderAndRenderPass(

    "Earth",

    ref positions,

    ref colors,

    ref indices,

    AgEStkGraphicsIndicesOrderHint.eStkGraphicsIndicesOrderHintSortedAscending,

    AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);

Shows the format of the Positions, Colors and Indices parameters when updating a polyline primitive.

[C#] Copy Code

// IAgStkGraphicsPolylinePrimitive polyline: A polyline primitive


Array positions = new object[]

{

    1247.87, -4739.74, 4067.77,

    1115.48, -4847.09, 3979.36,

    -24.12, -5529.31, 3168.45,

    -2683.42, -4307.74, 3850.11

};


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


Array indices = new object[]

{

    0,

    1,

    2,

    3

};


polyline.SetPartialWithColorsIndicesOrderAndRenderPassHint(

    ref positions,

    ref colors,

    ref indices,

    AgEStkGraphicsIndicesOrderHint.eStkGraphicsIndicesOrderHintSortedAscending,

    AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);

Draw a box

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// IAgCrdnSystem system: A system for the solid


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


Array size = new object[] {1000, 1000, 2000 };

IAgStkGraphicsSolidTriangulatorResult result = manager.Initializers.BoxTriangulator.Compute(ref size);

IAgStkGraphicsSolidPrimitive solid = manager.Initializers.SolidPrimitive.Initialize();

((IAgStkGraphicsPrimitive)solid).ReferenceFrame = system;

solid.SetWithResult(result);


manager.Primitives.Add((IAgStkGraphicsPrimitive)solid);

Draw a cylinder

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// IAgCrdnSystem system: A system for the solid


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsSolidTriangulatorResult result = manager.Initializers.CylinderTriangulator.CreateSimple(1000, 2000);

IAgStkGraphicsSolidPrimitive solid = manager.Initializers.SolidPrimitive.Initialize();

((IAgStkGraphicsPrimitive)solid).ReferenceFrame = system;

((IAgStkGraphicsPrimitive)solid).Color = Color.Yellow;

solid.OutlineColor = Color.Black;

solid.OutlineWidth = 2;

solid.OutlineAppearance = AgEStkGraphicsOutlineAppearance.eStkGraphicsStylizeBackLines;

solid.BackLineColor = Color.Black;

solid.BackLineWidth = 1;

solid.SetWithResult(result);


manager.Primitives.Add((IAgStkGraphicsPrimitive)solid);

Draw an ellipsoid

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// IAgCrdnSystem system: A system for the solid


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


Array radii = new object[] {2000, 1000, 1000 };

IAgStkGraphicsSolidTriangulatorResult result = manager.Initializers.EllipsoidTriangulator.ComputeSimple(ref radii);

IAgStkGraphicsSolidPrimitive solid = manager.Initializers.SolidPrimitive.Initialize();

((IAgStkGraphicsPrimitive)solid).ReferenceFrame = system;

((IAgStkGraphicsPrimitive)solid).Color =  Color.Orange;

((IAgStkGraphicsPrimitive)solid).Translucency = 0.3f;

solid.OutlineAppearance = AgEStkGraphicsOutlineAppearance.eStkGraphicsFrontLinesOnly;

solid.OutlineColor = Color.Blue;

solid.OutlineWidth = 2;

solid.DisplaySilhouette = true;

solid.SetWithResult(result);


manager.Primitives.Add((IAgStkGraphicsPrimitive)solid);

Draw a filled STK area target on terrain

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String terrainFile: The terrain file

// Array positions: The positions used to compute triangulation


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsTerrainOverlay overlay = scene.CentralBodies.Earth.Terrain.AddUriString(

    terrainFile);


IAgStkGraphicsSurfaceTriangulatorResult triangles =

    manager.Initializers.SurfacePolygonTriangulator.Compute("Earth", ref positions);


IAgStkGraphicsSurfaceMeshPrimitive mesh = manager.Initializers.SurfaceMeshPrimitive.Initialize();

((IAgStkGraphicsPrimitive)mesh).Color = Color.Purple;

mesh.Set(triangles);

manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Draw a filled STK area target on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String textureFile: The texture file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

//

// Load the UAV image where each corner maps to a longitude and latitude defined

// in degrees below.

//

//    lower left  = (-0.386182, 42.938583)

//    lower right = (-0.375100, 42.929871)

//    upper right = (-0.333891, 42.944780)

//    upper left  = (-0.359980, 42.973438)

//


IAgStkGraphicsRendererTexture2D texture = manager.Textures.LoadFromStringUri(

    textureFile);


//

// Define the bounding extent of the image.  Create a surface mesh that uses this extent.

//

IAgStkGraphicsSurfaceMeshPrimitive mesh = manager.Initializers.SurfaceMeshPrimitive.Initialize();

mesh.Texture = texture;


Array cartographicExtent = new object[]

{

    -0.386182,

    42.929871,

    -0.333891,

    42.973438

};


IAgStkGraphicsSurfaceTriangulatorResult triangles = manager.Initializers.SurfaceExtentTriangulator.ComputeSimple("Earth", ref cartographicExtent);

mesh.Set(triangles);

((IAgStkGraphicsPrimitive)mesh).Translucency = 0.0f;


//

// Create the texture matrix that maps the image corner points to their actual

// cartographic coordinates.  A few notes:

//

// 1. The TextureMatrix does not do any special processing on these values

//    as if they were cartographic coordinates.

//

// 2. Because of 1., the values only have to be correct relative to each

//    other, which is why they do not have to be converted to radians.

//

// 3. Because of 2., if your image straddles the +/- 180 degs longitude line,

//    ensure that longitudes east of the line are greater than those west of

//    the line.  For example, if one point were 179.0 degs longitude and the

//    other were to the east at -179.0 degs, the one to the east should be

//    specified as 181.0 degs.

//


Array c0 = new object[] { -0.386182, 42.938583 };

Array c1 = new object[] { -0.375100, 42.929871 };

Array c2 = new object[] { -0.333891, 42.944780 };

Array c3 = new object[] { -0.359980, 42.973438 };


mesh.TextureMatrix = manager.Initializers.TextureMatrix.InitializeWithRectangles(

    ref c0, ref c1, ref c2, ref c3);


//

// Enable the transparent texture border option on the mesh so that the texture will not

// bleed outside of the trapezoid.

//

mesh.TransparentTextureBorder = true;


//

// Add the surface mesh to the Scene manager

//

manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Draw a filled, dynamically textured extent on terrain

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String rasterFile: The file to use as the raster


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsProjectionRasterStreamPluginActivator activator =

    manager.Initializers.ProjectionRasterStreamPluginActivator.Initialize();

IAgStkGraphicsProjectionRasterStreamPluginProxy proxy =

    activator.CreateFromDisplayName("ProjectionRasterStreamPlugin.CSharp");


//

// Use reflection to set the plugin's properties

//

Type plugin = proxy.RealPluginObject.GetType();

plugin.GetProperty("RasterPath").SetValue(proxy.RealPluginObject, rasterFile, null);


IAgStkGraphicsRasterStream rasterStream = proxy.RasterStream;

rasterStream.UpdateDelta = 0.025;


IAgStkGraphicsRendererTexture2D texture = manager.Textures.FromRaster((IAgStkGraphicsRaster)rasterStream);

Array extent = ((IAgStkGraphicsGlobeOverlay)overlay).Extent;

IAgStkGraphicsSurfaceTriangulatorResult triangles = manager.Initializers.SurfaceExtentTriangulator.ComputeSimple("Earth", ref extent);

IAgStkGraphicsSurfaceMeshPrimitive mesh = manager.Initializers.SurfaceMeshPrimitive.Initialize();

((IAgStkGraphicsPrimitive)mesh).Translucency = 0.2f;

mesh.Texture = texture;

mesh.Set(triangles);

manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Draw a filled, textured extent on terrain

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String textureFile: The file to use as the texture of the surface mesh


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array overlayExtent = ((IAgStkGraphicsGlobeOverlay)overlay).Extent;

IAgStkGraphicsSurfaceTriangulatorResult triangles =

    manager.Initializers.SurfaceExtentTriangulator.ComputeSimple("Earth", ref overlayExtent);

IAgStkGraphicsRendererTexture2D texture = manager.Textures.LoadFromStringUri(

    textureFile);

IAgStkGraphicsSurfaceMeshPrimitive mesh = manager.Initializers.SurfaceMeshPrimitive.Initialize();

((IAgStkGraphicsPrimitive)mesh).Translucency = 0.3f;

mesh.Texture = texture;

mesh.Set(triangles);

manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Draw a moving water texture using affine transformations

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String textureFile: The file to use as the texture of the surface mesh


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array cartographicExtent = new object[]

{

    -96,

    22,

    -85,

    28

};


IAgStkGraphicsSurfaceTriangulatorResult triangles =

    manager.Initializers.SurfaceExtentTriangulator.ComputeSimple("Earth", ref cartographicExtent);


IAgStkGraphicsRendererTexture2D texture = manager.Textures.LoadFromStringUri(

    textureFile);

IAgStkGraphicsSurfaceMeshPrimitive mesh = manager.Initializers.SurfaceMeshPrimitive.Initialize();

((IAgStkGraphicsPrimitive)mesh).Translucency = 0.3f;

mesh.Texture = texture;

mesh.TextureFilter = manager.Initializers.TextureFilter2D.LinearRepeat;

mesh.Set(triangles);

manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);



internal void TimeChanged(IAgStkGraphicsScene scene, AgStkObjectRoot root, double TimeEpSec)

{

    //

    //  Translate the surface mesh every animation update

    //

    if (m_Primitive != null)

    {

        IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


        m_Translation = (float)TimeEpSec;

        m_Translation /= 1000;


        Matrix transformation = new Matrix();

        transformation.Translate(-m_Translation, 0); // Sign determines the direction of apparent flow


        // Convert the matrix to an object array

        Array transformationArray = Array.CreateInstance(typeof(object), transformation.Elements.Length);

        for (int i = 0; i < transformationArray.Length; ++i)

        {

            transformationArray.SetValue((object)transformation.Elements.GetValue(i), i);

        }


        ((IAgStkGraphicsSurfaceMeshPrimitive)m_Primitive).TextureMatrix =

            manager.Initializers.TextureMatrix.InitializeWithAffineTransform(ref transformationArray);

    }

}

Draw a set of strings

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


Array text = new object[]

{

    "Philadelphia",

    "Washington, D.C.",

    "New Orleans",

    "San Jose"

};


Array positions = new object[]

{

    39.88, -75.25, 0,    // Philadelphia

    38.85, -77.04, 0, // Washington, D.C.

    29.98, -90.25, 0, // New Orleans

    37.37, -121.92, 0    // San Jose

};


IAgStkGraphicsGraphicsFont font = manager.Initializers.GraphicsFont.InitializeWithNameSizeFontStyleOutline("MS Sans Serif", 12, AgEStkGraphicsFontStyle.eStkGraphicsFontStyleBold, true);

IAgStkGraphicsTextBatchPrimitive textBatch = manager.Initializers.TextBatchPrimitive.InitializeWithGraphicsFont(font);

((IAgStkGraphicsPrimitive)textBatch).Color = Color.White;

textBatch.OutlineColor = Color.Red;

textBatch.SetCartographic("Earth", ref positions, ref text);


manager.Primitives.Add((IAgStkGraphicsPrimitive)textBatch);

Draw a set of uniquely colored strings

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array strings = new object[]

{

    "San Francisco",

    "Sacramento",

    "Los Angeles",

    "San Diego"

};


Array positions = new object[]

{

    37.62, -122.38, 0.0,

    38.52, -121.50, 0.0,

    33.93, -118.40, 0.0,

    32.82, -117.13, 0.0

};


Array colors = new object[]

{

    (uint)Color.Red.ToArgb(),

    (uint)Color.Green.ToArgb(),

    (uint)Color.Blue.ToArgb(),

    (uint)Color.White.ToArgb()

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = manager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.SetColors(ref colors);


IAgStkGraphicsGraphicsFont font = manager.Initializers.GraphicsFont.InitializeWithNameSizeFontStyleOutline("MS Sans Serif", 12, AgEStkGraphicsFontStyle.eStkGraphicsFontStyleBold, false);

IAgStkGraphicsTextBatchPrimitive textBatch = manager.Initializers.TextBatchPrimitive.InitializeWithGraphicsFont(font);

textBatch.SetCartographicWithOptionalParameters("Earth", ref positions, ref strings, parameters);


manager.Primitives.Add((IAgStkGraphicsPrimitive)textBatch);

Shows the format of the Colors parameter when setting per string colors.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.SetColors(ref colors);

Shows the format of the EyeOffset property when setting the per-batch eye offset.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array eyeoffset = new object[]

{

    2,

    3,

    4

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.EyeOffset = eyeoffset;

Shows the format of the EyeOffsets parameter when setting per string eye offsets.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array eyeoffset = new object[]

{

    2, 3, 4,

    2, 3, 4

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.SetEyeOffsets(ref eyeoffset);

Shows the format of the Origins parameter when setting per string origins.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array origins = new object[]

{

    AgEStkGraphicsOrigin.eStkGraphicsOriginCenter,

    AgEStkGraphicsOrigin.eStkGraphicsOriginBottomLeft,

    AgEStkGraphicsOrigin.eStkGraphicsOriginBottomRight,

    AgEStkGraphicsOrigin.eStkGraphicsOriginTopLeft

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.SetOrigins(ref origins);

Shows the format of the PixelOffset property when setting the per-batch pixel offset.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array pixelOffset = new object[]

{

    1,

    2

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.PixelOffset = pixelOffset;

Shows the format of the PixelOffsets parameter when setting per string pixel offsets.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array pixelOffset = new object[]

{

    1, 2,

    2, 1

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.SetPixelOffsets(ref pixelOffset);

Shows the format of the Text, Positions, Colors and Indices parameters when updating a text batch primitive with cartographic positions.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// IAgStkGraphicsTextBatchPrimitive textBatch: A text batch primitive


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.SetColors(ref colors);


Array text = new object[]

{

    "Philadelphia",

    "Washington D.C.",

    "New Orleans",

    "San Jose"

};


Array positions = new object[]

{

    39.88, -75.25, 0,    // Philadelphia

    38.85, -77.04, 0, // Washington, D.C.

    29.98, -90.25, 0, // New Orleans

    37.37, -121.92, 0    // San Jose

};


Array indices = new object[]

{

    0,

    1,

    2,

    3

};


textBatch.SetPartialCartographicWithOptionalParametersIndicesOrderAndRenderPass(

    "Earth",

    ref positions,

    ref text,

    parameters,

    ref indices,

    AgEStkGraphicsIndicesOrderHint.eStkGraphicsIndicesOrderHintSortedAscending,

    AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);

Shows the format of the Text, Positions, Colors and Indices parameters when updating a text batch primitive.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// IAgStkGraphicsTextBatchPrimitive textBatch: A text batch primitive


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


IAgStkGraphicsTextBatchPrimitiveOptionalParameters parameters = sceneManager.Initializers.TextBatchPrimitiveOptionalParameters.Initialize();

parameters.SetColors(ref colors);


Array text = new object[]

{

    "Philadelphia",

    "Washington D.C.",

    "New Orleans",

    "San Jose"

};


Array positions = new object[]

{

    1247.87, -4739.74, 4067.77,

    1115.48, -4847.09, 3979.36,

    -24.12, -5529.31, 3168.45,

    -2683.42, -4307.74, 3850.11

};


Array indices = new object[]

{

    0,

    1,

    2,

    3

};


textBatch.SetPartialWithOptionalParametersIndicesOrderAndRenderPass(

    ref positions,

    ref text,

    parameters,

    ref indices,

    AgEStkGraphicsIndicesOrderHint.eStkGraphicsIndicesOrderHintSortedAscending,

    AgEStkGraphicsRenderPassHint.eStkGraphicsRenderPassHintOpaque);

Draw a filled circle on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array center = new object[] { 39.88, -75.25, 0.0 };


IAgStkGraphicsSurfaceShapesResult shape = manager.Initializers.SurfaceShapes.ComputeCircleCartographic("Earth", ref center, 10000);

Array positions = shape.Positions;

IAgStkGraphicsSurfaceTriangulatorResult triangles = manager.Initializers.SurfacePolygonTriangulator.Compute("Earth", ref positions);


IAgStkGraphicsTriangleMeshPrimitive mesh = manager.Initializers.TriangleMeshPrimitive.Initialize();

mesh.SetTriangulator((IAgStkGraphicsTriangulatorResult)triangles);

((IAgStkGraphicsPrimitive)mesh).Color = Color.White;

((IAgStkGraphicsPrimitive)mesh).Translucency = 0.5f;


manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Draw a filled ellipse on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Array center = new object[] { 38.85, -77.04, 3000.0 }; // Washington, DC


IAgStkGraphicsSurfaceShapesResult shape = manager.Initializers.SurfaceShapes.ComputeEllipseCartographic(

    "Earth", ref center, 45000, 30000, 45);

Array positions = shape.Positions;


IAgStkGraphicsSurfaceTriangulatorResult triangles = manager.Initializers.SurfacePolygonTriangulator.Compute(

    "Earth", ref positions);

IAgStkGraphicsTriangleMeshPrimitive mesh = manager.Initializers.TriangleMeshPrimitive.Initialize();

mesh.SetTriangulator((IAgStkGraphicsTriangulatorResult)triangles);

((IAgStkGraphicsPrimitive)mesh).Color = Color.Cyan;


manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Draw a filled polygon with a hole on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// Array positions: The positions used to compute triangulation

// Array holePositions: The positions of the hole


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsSurfaceTriangulatorResult triangles = manager.Initializers.SurfacePolygonTriangulator.ComputeWithHole(

    "Earth", ref positions, ref holePositions);


IAgStkGraphicsTriangleMeshPrimitive mesh = manager.Initializers.TriangleMeshPrimitive.Initialize();

mesh.SetTriangulator((IAgStkGraphicsTriangulatorResult)triangles);

((IAgStkGraphicsPrimitive)mesh).Color = Color.Gray;

((IAgStkGraphicsPrimitive)mesh).Translucency = 0.5f;

manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);


IAgStkGraphicsPolylinePrimitive boundaryLine = manager.Initializers.PolylinePrimitive.Initialize();

Array boundaryPositionsArray = triangles.BoundaryPositions;

boundaryLine.Set(ref boundaryPositionsArray);

((IAgStkGraphicsPrimitive)boundaryLine).Color = Color.Red;

boundaryLine.Width = 2;

manager.Primitives.Add((IAgStkGraphicsPrimitive)boundaryLine);


IAgStkGraphicsPolylinePrimitive holeLine = manager.Initializers.PolylinePrimitive.Initialize();

holeLine.Set(ref holePositions);

((IAgStkGraphicsPrimitive)holeLine).Color = Color.Red;

holeLine.Width = 2;

manager.Primitives.Add((IAgStkGraphicsPrimitive)holeLine);

Draw a filled rectangular extent on the globe

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


Array extent = new object[]

{

    -94, 29,

    -89, 33

};


IAgStkGraphicsSurfaceTriangulatorResult triangles = manager.Initializers.SurfaceExtentTriangulator.ComputeSimple(

        "Earth", ref extent);


IAgStkGraphicsTriangleMeshPrimitive mesh = manager.Initializers.TriangleMeshPrimitive.Initialize();

mesh.SetTriangulator((IAgStkGraphicsTriangulatorResult)triangles);

((IAgStkGraphicsPrimitive)mesh).Color = Color.Salmon;

mesh.Lighting = false;  /* Turn off lighting for the mesh so the color we assigned will always be consistent */


manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Draw a filled STK area target

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// Array positions: The positions used to compute triangulation


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsSurfaceTriangulatorResult triangles =

    manager.Initializers.SurfacePolygonTriangulator.Compute("Earth", ref positions);


IAgStkGraphicsTriangleMeshPrimitive mesh = manager.Initializers.TriangleMeshPrimitive.Initialize();

mesh.SetTriangulator((IAgStkGraphicsTriangulatorResult)triangles);

((IAgStkGraphicsPrimitive)mesh).Color = Color.Red;

manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Draw an extrusion around a STK area target

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// Array positions: The positions used to compute triangulation


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;


IAgStkGraphicsExtrudedPolylineTriangulatorResult triangles =

    manager.Initializers.ExtrudedPolylineTriangulator.ComputeWithAltitudes(

    "Earth", ref positions, 10000, 25000);

IAgStkGraphicsTriangleMeshPrimitive mesh = manager.Initializers.TriangleMeshPrimitive.Initialize();

mesh.SetTriangulator((IAgStkGraphicsTriangulatorResult)triangles);

((IAgStkGraphicsPrimitive)mesh).Color = Color.Red;

((IAgStkGraphicsPrimitive)mesh).Translucency = 0.4f;


manager.Primitives.Add((IAgStkGraphicsPrimitive)mesh);

Shows the format of the Colors parameter when setting per vertex colors.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array colors = new object[]

{

    Color.Red.ToArgb(),

    Color.Green.ToArgb(),

    Color.Blue.ToArgb(),

    Color.White.ToArgb()

};


IAgStkGraphicsTriangleMeshPrimitiveOptionalParameters parameters = sceneManager.Initializers.TriangleMeshPrimitiveOptionalParameters.Initialize();

parameters.SetPerVertexColors(ref colors);

Shows the format of the Positions, Normals and Indices parameters when updating a triangle mesh primitive.

[C#] Copy Code

// IAgStkGraphicsTriangleMeshPrimitive triangleMesh: A triangle mesh primitive


Array positions = new object[]

{

    0, 0, 0,

    70000, 0, 0,

    0, 70000, 0

};


Array normals = new object[]

{

    0, 0, 1,

    0, 0, 1,

    0, 0, 1

};


Array indices = new object[]

{

    0,

    1,

    2

};


triangleMesh.Set(ref positions, ref normals, ref indices);

Shows the format of the TextureCoordinates parameter when setting per vertex texture coordinates.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array coordinates = new object[]

{

    0, 0, 1, 1,

    0, 0, 1, 1

};


IAgStkGraphicsTriangleMeshPrimitiveOptionalParameters parameters = sceneManager.Initializers.TriangleMeshPrimitiveOptionalParameters.Initialize();

parameters.SetTextureCoordinates(ref coordinates);

Shows the format of the Position parameter when creating a projection.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// IAgOrientation orientation: A valid orientation object.


Array position = new object[]

{

    31378.1,

    0,

    0

};


IAgStkGraphicsProjection projection = sceneManager.Initializers.Projection.InitializeWithData(

    ref position,

    orientation,

    200,

    200,

    20,

    10000);

Shows the format of the projection's Position property.

[C#] Copy Code

// IAgStkGraphicsProjection projection: A valid projection object


Array position = new object[]

{

    31378.1,

    0,

    0

};


projection.Position = position;

How to get the scene manager from the STK Object Model root.

[C#] Copy Code

// AgStkObjectRoot root: STK Object Model root


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

Add a company logo with a texture overlay

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: The image file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;


IAgStkGraphicsRendererTexture2D texture2D = manager.Textures.LoadFromStringUri(

    imageFile);


IAgStkGraphicsTextureScreenOverlay overlay = manager.Initializers.TextureScreenOverlay.InitializeWithXYWidthHeight(

    10, 0,

    texture2D.Template.Width / 2,

    texture2D.Template.Height / 2);

((IAgStkGraphicsOverlay)overlay).Translucency = 0.1f;

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginBottomRight;

overlay.Texture = texture2D;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Add a video with a texture overlay

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String videoFile: The video file


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;


IAgStkGraphicsVideoStream videoStream = manager.Initializers.VideoStream.InitializeWithStringUri(videoFile);

videoStream.Playback = AgEStkGraphicsVideoPlayback.eStkGraphicsVideoPlaybackRealTime;

videoStream.Loop = true;


IAgStkGraphicsTextureScreenOverlay overlay = manager.Initializers.TextureScreenOverlay.InitializeWithXYWidthHeight(

    0, 0,

    ((IAgStkGraphicsRaster)videoStream).Width / 4,

    ((IAgStkGraphicsRaster)videoStream).Height / 4);

((IAgStkGraphicsOverlay)overlay).Translucency = 0.3f;

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginTopRight;

((IAgStkGraphicsOverlay)overlay).BorderSize = 1;

((IAgStkGraphicsOverlay)overlay).BorderTranslucency = 0.3f;

overlay.Texture = manager.Textures.FromRaster((IAgStkGraphicsRaster)videoStream);


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Add overlays to a panel overlay

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String imageFile: The image file to use for the child overlay

// String rasterFile: The raster file for the second child overlay


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;


IAgStkGraphicsTextureScreenOverlay overlay =

    manager.Initializers.TextureScreenOverlay.InitializeWithXYWidthHeight(0, 0,

    188, 200);

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginTopLeft;

((IAgStkGraphicsOverlay)overlay).Color = Color.LightSkyBlue;

((IAgStkGraphicsOverlay)overlay).Translucency = 0.7f;

((IAgStkGraphicsOverlay)overlay).BorderTranslucency = 0.3f;

((IAgStkGraphicsOverlay)overlay).BorderSize = 1;

((IAgStkGraphicsOverlay)overlay).BorderColor = Color.LightBlue;


IAgStkGraphicsTextureScreenOverlay childOverlay =

    manager.Initializers.TextureScreenOverlay.InitializeWithXYWidthHeight(

    0, 0, ((IAgStkGraphicsOverlay)overlay).Width, ((IAgStkGraphicsOverlay)overlay).Height);

((IAgStkGraphicsOverlay)childOverlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginCenter;


childOverlay.Texture = manager.Textures.LoadFromStringUri(imageFile);


//

// Create the RasterStream from the plugin the same way as in ImageDynamicCodeSnippet.cs

//

IAgStkGraphicsProjectionRasterStreamPluginActivator activator =

    manager.Initializers.ProjectionRasterStreamPluginActivator.Initialize();

IAgStkGraphicsProjectionRasterStreamPluginProxy proxy =

    activator.CreateFromDisplayName("ProjectionRasterStreamPlugin.CSharp");

Type plugin = proxy.RealPluginObject.GetType();

plugin.GetProperty("RasterPath").SetValue(proxy.RealPluginObject, rasterFile, null);


IAgStkGraphicsRasterStream rasterStream = proxy.RasterStream;

rasterStream.UpdateDelta = 0.01667;

IAgStkGraphicsRendererTexture2D texture2D = manager.Textures.FromRaster((IAgStkGraphicsRaster)rasterStream);


IAgStkGraphicsTextureScreenOverlay secondChildOverlay =

    manager.Initializers.TextureScreenOverlay.InitializeWithXYWidthHeight(0, 0,

    128, 128);

((IAgStkGraphicsOverlay)secondChildOverlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginTopRight;

((IAgStkGraphicsOverlay)secondChildOverlay).TranslationX = -36;

((IAgStkGraphicsOverlay)secondChildOverlay).TranslationY = -18;

((IAgStkGraphicsOverlay)secondChildOverlay).ClipToParent = false;

secondChildOverlay.Texture = texture2D;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);


IAgStkGraphicsScreenOverlayCollectionBase parentOverlayManager = ((IAgStkGraphicsOverlay)overlay).Overlays as IAgStkGraphicsScreenOverlayCollectionBase;

parentOverlayManager.Add((IAgStkGraphicsScreenOverlay)childOverlay);


IAgStkGraphicsScreenOverlayCollectionBase childOverlayManager = ((IAgStkGraphicsOverlay)childOverlay).Overlays as IAgStkGraphicsScreenOverlayCollectionBase;

childOverlayManager.Add((IAgStkGraphicsScreenOverlay)secondChildOverlay);

Shows the format of the Position and Size parameters when creating a screen overlay.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array position = new object[]

{

    0,

    0,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


Array size = new object[]

{

    100,

    200,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


IAgStkGraphicsScreenOverlay screenOverlay = sceneManager.Initializers.ScreenOverlay.InitializeWithPosAndSize(ref position, ref size);

Shows the format of the screen overlay manager's Padding property.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array padding = new object[]

{

    10,

    10,

    10,

    10

};


sceneManager.ScreenOverlays.Padding = padding;

Write text to a texture overlay

[C#] Copy Code

// IAgStkGraphicsScene scene: Current Scene

// AgStkObjectRoot root: STK Object Model root

// String temporaryFile: The file to which the bitmap will be temporarily saved (should not exist yet)


IAgStkGraphicsSceneManager manager = ((IAgScenario)root.CurrentScenario).SceneManager;

IAgStkGraphicsScreenOverlayCollectionBase overlayManager = (IAgStkGraphicsScreenOverlayCollectionBase)manager.ScreenOverlays.Overlays;


Font font = new Font("Arial", 12, FontStyle.Bold);

string text = "STK Engine\nAnalytical Graphics\nOverlays";

Size textSize = MeasureString(text, font);

Bitmap textBitmap = new Bitmap(textSize.Width, textSize.Height);

Graphics gfx = Graphics.FromImage(textBitmap);

gfx.DrawString(text, font, Brushes.White, new PointF(0, 0));


IAgStkGraphicsTextureScreenOverlay overlay =

    manager.Initializers.TextureScreenOverlay.InitializeWithXYWidthHeight(10, 10, textSize.Width, textSize.Height);

((IAgStkGraphicsOverlay)overlay).Origin = AgEStkGraphicsScreenOverlayOrigin.eStkGraphicsScreenOverlayOriginBottomLeft;


//

// Any bitmap can be written to a texture by temporarily saving the texture to disk.

//

string filePath = temporaryFile;

textBitmap.Save(filePath);

overlay.Texture = manager.Textures.LoadFromStringUri(filePath);

System.IO.File.Delete(filePath); // The temporary file is not longer required and can be deleted


overlay.TextureFilter = manager.Initializers.TextureFilter2D.NearestClampToEdge;


overlayManager.Add((IAgStkGraphicsScreenOverlay)overlay);

Shows the format of the Extent parameter when computing using a surface extent triangulator.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


//The LongitudeUnit and LatitudeUnit is expected to be in degrees

Array extent = new object[]

{

    90,

    30,

    -77,

    39

};


IAgStkGraphicsSurfaceTriangulatorResult result = sceneManager.Initializers.SurfaceExtentTriangulator.ComputeSimple(

    "Earth",

    ref extent);

Shows the format of the Positions and HolePositions parameters when computing using a surface polygon triangulator.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array positions = new object[]

{

    1097959.63, -5171334.09, 3556288,

    1007572.15, -5150349.71, 3612667.74,

    978879.05, -5195164.23, 3556326.55,

    1037389.68, -5188523.96, 3549473.77,

    1097959.63, -5171334.09, 3556288

};


Array holePositions = new object[]

{

    1079859.69, -5169944.96, 3563791.24,

    1030755, -5179965.11, 3563781.97,

    1028569.57, -5145251.03, 3614006.53,

    1039944.33, -5153880.71, 3598525.9,

    1027115.87, -5150522.49, 3606951.77,

    1026998.55, -5162243.13, 3590303.25,

    1079859.69, -5169944.96, 3563791.24

};


IAgStkGraphicsSurfaceTriangulatorResult result = sceneManager.Initializers.SurfacePolygonTriangulator.ComputeWithHole("Earth", ref positions, ref holePositions);

Shows the format of the Positions parameter when computing using a surface polygon triangulator.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array positions = new object[]

{

    34.11, -78.01, 0,

    34.72, -78.93, 0,

    34.11, -79.33, 0,

    34.03, -78.69, 0,

    34.11, -78.01, 0

};


IAgStkGraphicsSurfaceTriangulatorResult result = sceneManager.Initializers.SurfacePolygonTriangulator.ComputeCartographic(

    "Earth",

    ref positions);

Shows the format of the Center parameter when computing a circle with a cartographic position.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array center = new object[]

{

    39.88,

    -75.25,

    0.0

};


IAgStkGraphicsSurfaceShapesResult shape = sceneManager.Initializers.SurfaceShapes.ComputeCircleCartographic(

    "Earth",

    ref center,

    10000);

Shows the format of the Center parameter when computing a circle.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array center = new object[]

{

    1247.87,

    -4739.74,

    4067.77

};


IAgStkGraphicsSurfaceShapesResult shape = sceneManager.Initializers.SurfaceShapes.ComputeCircle(

    "Earth",

    ref center,

    10000);

Shows the format of the Center parameter when computing a sector with a cartographic position.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


//The AngleUnit is expected to be in degrees

Array center = new object[]

{

    0,

    0,

    25000

};


IAgStkGraphicsSurfaceShapesResult shape = sceneManager.Initializers.SurfaceShapes.ComputeSectorCartographic(

    "Earth",

    ref center,

    100,

    350,

    -30,

    30);

Shows the format of the Center parameter when computing a sector.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


//The AngleUnit is expected to be in degrees

Array center = new object[]

{

    6403.14,

    0,

    0

};


IAgStkGraphicsSurfaceShapesResult shape = sceneManager.Initializers.SurfaceShapes.ComputeSector(

    "Earth",

    ref center,

    100,

    350,

    -30,

    30);

Shows the format of the Center parameter when computing an ellipse with a cartographic position.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array center = new object[]

{

    38.85,

    -77.04,

    3000.0

};


IAgStkGraphicsSurfaceShapesResult shape = sceneManager.Initializers.SurfaceShapes.ComputeEllipseCartographic(

    "Earth",

    ref center,

    45000,

    30000,

    45);

Shows the format of the Center parameter when computing an ellipse.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array center = new object[]

{

    1639.46,

    -7123.95,

    5861.21

};


IAgStkGraphicsSurfaceShapesResult shape = sceneManager.Initializers.SurfaceShapes.ComputeEllipse(

    "Earth",

    ref center,

    45000,

    30000,

    45);

Shows the format of the Corner0, Corner1, Corner2 and Corner3 parameters when creating a texture matrix.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// IAgStkGraphicsSurfaceMeshPrimitive surfaceMesh: A surface mesh primitive


Array lowerLeftCorner = new object[]

{

    -0.386182,

    42.938583

};

Array lowerRightCorner = new object[]

{

    -0.375100,

    42.929871

};

Array upperRightCorner = new object[]

{

    -0.333891,

    42.944780

};

Array upperLeftCorner = new object[]

{

    -0.359980,

    42.973438

};


surfaceMesh.TextureMatrix = sceneManager.Initializers.TextureMatrix.InitializeWithRectangles(

    ref lowerLeftCorner, ref lowerRightCorner, ref upperRightCorner, ref upperLeftCorner);

Shows the format of the Matrix parameter when creating a texture matrix.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager

// IAgStkGraphicsSurfaceMeshPrimitive surfaceMesh: A surface mesh primitive


Array transformationArray = new object[]

{

    1.0, 0.0, 0.0,

    1.0, 0.0, 0.0

};


surfaceMesh.TextureMatrix = sceneManager.Initializers.TextureMatrix.InitializeWithAffineTransform(

    ref transformationArray);

Shows the format of the Position and Size parameters when creating a texture screen overlay.

[C#] Copy Code

// IAgStkGraphicsSceneManager sceneManager: The STK Graphics scene manager


Array position = new object[]

{

    0,

    0,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


Array size = new object[]

{

    100,

    200,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels,

    AgEStkGraphicsScreenOverlayUnit.eStkGraphicsScreenOverlayUnitPixels

};


IAgStkGraphicsTextureScreenOverlay screenOverlay = sceneManager.Initializers.TextureScreenOverlay.InitializeWithPositionSize(ref position, ref size);

Create a duplicate.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of a VGT provider


IAgCrdnPoint point = provider.Points.Factory.Create("OriginalPoint", "description", AgECrdnPointType.eCrdnPointTypeAtTimeInstant);

IAgCrdn duplicate = ((IAgCrdn)point).Duplicate("DuplicatePoint", "description");

Create an anonymous duplicate.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of a VGT provider


IAgCrdnPoint point = provider.Points.Factory.Create("OriginalPoint", "description", AgECrdnPointType.eCrdnPointTypeAtTimeInstant);

IAgCrdn anonymousDuplicate = ((IAgCrdn)point).AnonymousDuplicate();

Enumerate all embedded components of a VGT component

[C#] Copy Code

// IAgCrdn crdn: A VGT component


foreach (IAgCrdn embeddedComponent in crdn.EmbeddedComponents)

{

    Console.WriteLine("Name: {0}, kind: {1}", embeddedComponent.Name, embeddedComponent.Kind);

}

Get a Vector Geometry Tool provider

[C#] Copy Code

// IAgCrdnRoot root: A VGT root object

// String path: A short name referring to an instance of STK Object or Central Body


//Returns a provider associated with the specified

// instance of an STK Object or a Central Body.

IAgCrdnProvider provider = root.GetProvider(path);

Get A Vector Geometry Tool template provider.

[C#] Copy Code

// IAgCrdnRoot root: A VGT root object

// String className: A class name of STK Object or Central Body


//Returns a VGT provider associated with the specified

// STK object class (i.e., Satellite, Facility, etc.) or

// a Central Body.

IAgCrdnProvider provider = root.GetTemplateProvider(className);

Get an embedded component

[C#] Copy Code

// IAgCrdn crdn: A VGT component


if (crdn.EmbeddedComponents.Contains("Origin"))

{

    IAgCrdn embeddedComponent = crdn.EmbeddedComponents["Origin"];

}

Iterate all embedded components of a VGT component

[C#] Copy Code

// IAgCrdn crdn: A VGT component


for (int i = 0; i < crdn.EmbeddedComponents.Count; i++)

{

    IAgCrdn embeddedComponent = crdn.EmbeddedComponents[i];

    Console.WriteLine("Name: {0}, kind: {1}", embeddedComponent.Name, embeddedComponent.Kind);

}

Check whether an angle with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if an angle with the specified name already exists.

if (provider.Angles.Contains("AngleName"))

{

    Console.WriteLine("The angle \"{0}\" already exists!", "AngleName");

}

Check whether the reference angle has a cyclic dependency on another angle.

[C#] Copy Code

// IAgCrdnAngleRefTo angleRefTo: Reference to a angle.

// IAgCrdnAngle angle: A angle to check against reference angle.


//Check if the reference angle has a cyclic dependency on another angle.

if (angleRefTo.HasCyclicDependency(angle))

{

    Console.WriteLine("The angle {0} has a cyclic dependency on angle {1}.", ((IAgCrdn)angleRefTo.GetAngle()).Name, ((IAgCrdn)angle).Name);

}

Computes an angle and the rate of change at a given condition.

[C#] Copy Code

// IAgCrdnAngle angle: A valid VGT angle object.


IAgCrdnAngleFindAngleWithRateResult result = angle.FindAngleWithRate(0);

if (result.IsValid)

{

    Console.WriteLine("Angle: {0}, Rate: {1}", result.Angle, result.AngleRate);

}

Computes an angle at a given condition.

[C#] Copy Code

// IAgCrdnAngle angle: A valid VGT angle object.


IAgCrdnAngleFindAngleResult result = angle.FindAngle(0);

if (result.IsValid)

{

    Console.WriteLine("Angle: {0}", result.Angle);

}

Create a vector.perpendicular to the plane in which the angle is defined.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// Create a vector.perpendicular to the plane in which the angle is defined.

IAgCrdnVectorAngleRate vector = (IAgCrdnVectorAngleRate)provider.Vectors.Factory.Create(

    "myVector",

    "a vector.perpendicular to the plane in which the angle is defined.", AgECrdnVectorType.eCrdnVectorTypeAngleRate);

Create an angle between two planes.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


//Create an angle between two planes.

IAgCrdnAngleBetweenPlanes angle = (IAgCrdnAngleBetweenPlanes)provider.Angles.Factory.Create(

    "AngleName", "Angle from one plane to another.", AgECrdnAngleType.eCrdnAngleTypeBetweenPlanes);

Determine if the specified angle type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnAngleType angleType: An angle type.


// Check if the specified angle type is supported.

if (provider.Angles.Factory.IsTypeSupported(angleType))

{

    //Create an Angle with the supported Type

    IAgCrdnAngle angle = provider.Angles.Factory.Create(

        "MyAngle", string.Empty,

        angleType);

}

Enumerate the existing angles.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing angles.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing angle with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the vector with specified name exists

if (provider.Angles.Contains("AngleName"))

{

    provider.Angles.Remove("AngleName");

}

Check whether the axes with specified name exist.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if the axes with specified name exist

if (provider.Axes.Contains("AxesName"))

{

    Console.WriteLine("Axes \"{0}\" already exist!", "AxesName");

}

Check whether the reference axes has a cyclic dependency on another axes.

[C#] Copy Code

// IAgCrdnAxesRefTo axesRefTo: Reference to a axes.

// IAgCrdnAxes axes: A axes to check against reference axes.


//Check if the reference axes has a cyclic dependency on another axes.

if (axesRefTo.HasCyclicDependency(axes))

{

    Console.WriteLine("The axes {0} has a cyclic dependency on axes {1}.", ((IAgCrdn)axesRefTo.GetAxes()).Name, ((IAgCrdn)axes).Name);

}

Create the axes oriented using vectors fixed in these axes and independent reference vectors.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


IAgCrdnAxesAlignedAndConstrained axes = (IAgCrdnAxesAlignedAndConstrained)provider.Axes.Factory.Create(

    "AxesName", string.Empty, AgECrdnAxesType.eCrdnAxesTypeAlignedAndConstrained);

Creates a fixed axes based on the origin point with Euler Angles orientation (using common tasks).

[C#] Copy Code

// IAgCrdnProvider provider: An instance of a central body VGT provider

// IAgFacility facility: An instance of a facility


object lat = 0, lon = 0;

double alt = 0;


facility.Position.QueryPlanetodetic(out lat, out lon, out alt);

IAgCrdnPointFixedInSystem origin = provider.Points.CommonTasks.CreateFixedInSystemCartographic(provider.Systems["Fixed"], lat, lon, alt);

IAgCrdnAxesFixed eastNorthUp = provider.Axes.CommonTasks.CreateTopocentricAxesEulerAngles((IAgCrdnPoint)origin, AGI.STKUtil.AgEEulerOrientationSequence.e321, 90.0, 0.0, 0.0);

Creates a fixed axes based on the origin point with Quaternion orientation (using common tasks).

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// IAgFacility facility: An instance of a facility


object lat = 0, lon = 0;

double alt = 0;


facility.Position.QueryPlanetodetic(out lat, out lon, out alt);

IAgCrdnPointFixedInSystem origin = provider.Points.CommonTasks.CreateFixedInSystemCartographic(provider.Systems["Fixed"], lat, lon, alt);

IAgCrdnAxesFixed eastNorthUp = provider.Axes.CommonTasks.CreateTopocentricAxesQuaternion((IAgCrdnPoint)origin, 0.0, 0.0, 0.0, 1.0);

Creates a fixed axes based on the specified axes (using common tasks).

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


IAgCrdnAxes ecfAxes = provider.WellKnownAxes.Earth.Fixed;

IAgCrdnAxesFixed axesFixed = provider.Axes.CommonTasks.CreateFixed(ecfAxes);

Determine if the specified axes type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// AgECrdnAxesType axesType: An axes type.


if (provider.Axes.Factory.IsTypeSupported(axesType))

{

    IAgCrdnAxes axes = provider.Axes.Factory.Create(

        "AxesName", string.Empty, axesType);

}

Enumerate the existing axes.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Finds the axes' orientation in Earth's Fixed axes.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// IAgCrdnAxes axes: A valid VGT axes object.


IAgCrdnAxesFindInAxesResult result = axes.FindInAxes(0,

    provider.WellKnownAxes.Earth.Fixed);

if (result.IsValid)

{

    AGI.STKUtil.IAgOrientationEulerAngles angles;

    angles = (AGI.STKUtil.IAgOrientationEulerAngles)result.Orientation.ConvertTo(AGI.STKUtil.AgEOrientationType.eEulerAngles);

    Console.WriteLine("Euler Angles [A,B,C,SEQ] => [{1}, {1}, {2}, {3}]", angles.A, angles.B, angles.C, angles.Sequence);

}

Iterate through existing axes.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing axes with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the axes with specified name exist

if (provider.Axes.Contains("AxesName"))

{

    provider.Axes.Remove("AxesName");

}

Transform a vector and vector's rate to the Earth's Fixed axes.

[C#] Copy Code

// IAgStkObject sat: A satellite object.


int numEpSec = 180;


// Get the satellite's ICRF cartesian position at 180 EpSec using the data provider interface

IAgDataProviderGroup dpGroup = sat.DataProviders["Cartesian Position"] as IAgDataProviderGroup;

Array elements = new object[] { "x", "y", "z" };

IAgDataPrvTimeVar dp = dpGroup.Group["ICRF"] as IAgDataPrvTimeVar;

IAgDrResult dpResult = dp.ExecElements(numEpSec, numEpSec, 60, ref elements);

double xICRF = (double)dpResult.DataSets[0].GetValues().GetValue(0);

double yICRF = (double)dpResult.DataSets[1].GetValues().GetValue(0);

double zICRF = (double)dpResult.DataSets[2].GetValues().GetValue(0);


// Get the satellite's ICRF cartesian velocity at 180 EpSec using the data provider interface

dpGroup = sat.DataProviders["Cartesian Velocity"] as IAgDataProviderGroup;

dp = dpGroup.Group["ICRF"] as IAgDataPrvTimeVar;

dpResult = dp.ExecElements(numEpSec, numEpSec, 60, ref elements);

double xvelICRF = (double)dpResult.DataSets[0].GetValues().GetValue(0);

double yvelICRF = (double)dpResult.DataSets[1].GetValues().GetValue(0);

double zvelICRF = (double)dpResult.DataSets[2].GetValues().GetValue(0);


// Create a position vector using the ICRF coordinates

IAgCrdnAxes axesICRF = sat.Vgt.WellKnownAxes.Earth.ICRF;

IAgCartesian3Vector vectorICRF = Application.ConversionUtility.NewCartesian3Vector();

vectorICRF.Set(xICRF, yICRF, zICRF);


// Create a velocity vector using the ICRF coordinates

IAgCartesian3Vector vectorvelICRF = Application.ConversionUtility.NewCartesian3Vector();

vectorvelICRF.Set(xvelICRF, yvelICRF, zvelICRF);


// Use the TransformWithRate method to transform ICRF to Fixed

IAgCrdnAxes axesFixed = sat.Vgt.WellKnownAxes.Earth.Fixed;

IAgCrdnAxesTransformWithRateResult result = axesICRF.TransformWithRate(numEpSec, axesFixed, vectorICRF, vectorvelICRF);


// Get the Fixed position and velocity coordinates

double xFixed = result.Vector.X;

double yFixed = result.Vector.Y;

double zFixed = result.Vector.Z;

double xvelFixed = result.Velocity.X;

double yvelFixed = result.Velocity.Y;

double zvelFixed = result.Velocity.Z;

Transform a vector to the Earth's Fixed axes.

[C#] Copy Code

// IAgStkObject sat: A satellite object.


// Get the satellite's ICRF cartesian position at 180 EpSec using the data provider interface

int numEpSec = 180;

IAgDataProviderGroup dpGroup = sat.DataProviders["Cartesian Position"] as IAgDataProviderGroup;

Array elements = new object[] { "x", "y", "z" };

IAgDataPrvTimeVar dp = dpGroup.Group["ICRF"] as IAgDataPrvTimeVar;

IAgDrResult dpResult = dp.ExecElements(numEpSec, numEpSec, 60, ref elements);

double xICRF = (double)dpResult.DataSets[0].GetValues().GetValue(0);

double yICRF = (double)dpResult.DataSets[1].GetValues().GetValue(0);

double zICRF = (double)dpResult.DataSets[2].GetValues().GetValue(0);


// Create a vector using the ICRF coordinates

IAgCrdnAxes axesICRF = sat.Vgt.WellKnownAxes.Earth.ICRF;

IAgCartesian3Vector vectorICRF = Application.ConversionUtility.NewCartesian3Vector();

vectorICRF.Set(xICRF, yICRF, zICRF);


// Use the Transform method to transform ICRF to Fixed

IAgCrdnAxes axesFixed = sat.Vgt.WellKnownAxes.Earth.Fixed;

IAgCrdnAxesTransformResult result = axesICRF.Transform(numEpSec, axesFixed, vectorICRF);


// Get the Fixed coordinates

double xFixed = result.Vector.X;

double yFixed = result.Vector.Y;

double zFixed = result.Vector.Z;

Check whether a calc scalar with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if a calc scalar with the specified name already exists.

if (provider.CalcScalars.Contains("CalcScalarName"))

{

    Console.WriteLine("The calc scalar \"{0}\" already exists!", "CalcScalarName");

}

Create a calc scalar constant.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


//Create a calc scalar constant.

IAgCrdnCalcScalarConstant calcScalar = (IAgCrdnCalcScalarConstant)provider.CalcScalars.Factory.Create(

    "CalcScalarName", "Calc scalar constant.", AgECrdnCalcScalarType.eCrdnCalcScalarTypeConstant);

Determine if the specified calc scalar type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnCalcScalarType calcScalarType: A calc scalar type.


// Check if the specified calc scalar type is supported.

if (provider.CalcScalars.Factory.IsTypeSupported(calcScalarType))

{

    //Create a CalcScalar with the supported Type

    IAgCrdnCalcScalar calcScalar = provider.CalcScalars.Factory.Create(

        "MyCalcScalar", string.Empty,

        calcScalarType);

}

Enumerate the existing calc scalars.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing calc scalars.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing calc scalar with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the calc scalar with specified name exists

if (provider.CalcScalars.Contains("CalcScalarName"))

{

    provider.CalcScalars.Remove("CalcScalarName");

}

Check whether a condition with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if a condition with the specified name already exists.

if (provider.Conditions.Contains("ConditionName"))

{

    Console.WriteLine("The condition \"{0}\" already exists!", "ConditionName");

}

Create a condition defined by determining if input scalar is within specified bounds.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


//Create a condition from a scalar.

IAgCrdnConditionScalarBounds condition = (IAgCrdnConditionScalarBounds)provider.Conditions.Factory.Create(

    "ConditionName", "Condition from a scalar.", AgECrdnConditionType.eCrdnConditionTypeScalarBounds);

Determine if the specified condition type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnConditionType conditionType: A condition type.


// Check if the specified condition type is supported.

if (provider.Conditions.Factory.IsTypeSupported(conditionType))

{

    //Create a Condition with the supported Type

    IAgCrdnCondition condition = provider.Conditions.Factory.Create(

        "MyCondition", string.Empty,

        conditionType);

}

Enumerate the existing conditions.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing conditions.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing condition with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the condition with specified name exists

if (provider.Conditions.Contains("ConditionName"))

{

    provider.Conditions.Remove("ConditionName");

}

Check whether an event with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if an event with the specified name already exists.

if (provider.Events.Contains("EventName"))

{

    Console.WriteLine("The event \"{0}\" already exists!", "EventName");

}

Configure the smart interval epoch and the duration.

[C#] Copy Code

// IAgCrdnEventIntervalSmartInterval smartInterval: The time component smart interval


// Change the time interval to 1 week after the dependent interval.

IAgCrdnEventSmartEpoch epochOfInterest = smartInterval.GetStopEpoch();

smartInterval.SetStartEpochAndDuration(epochOfInterest, "+1 week");


// Or if you want a specific time, use SetStartTimeAndDuration.

smartInterval.SetStartTimeAndDuration("1 Jan 2015 16:00:00.000", "+1 day");


// You can find the event times, such as

Console.WriteLine("Start Time: " + smartInterval.FindStartTime());

Console.WriteLine("Stop Time: " + smartInterval.FindStopTime());

Console.WriteLine("Duration: " + smartInterval.DurationAsString); // Note, only works if you specified duration.

Configure the start and stop epoch time with smart epochs.

[C#] Copy Code

// IAgCrdnEventIntervalSmartInterval smartInterval: Event Smart Interval

// IAgCrdnEvent startEventEpoch: Start event epoch

// IAgCrdnEvent stopEventEpoch: Stop event epoch


smartInterval.State = AgECrdnSmartIntervalState.eCrdnSmartIntervalStateStartStop;


IAgCrdnEventSmartEpoch accessStartEpoch = smartInterval.GetStartEpoch();

accessStartEpoch.SetImplicitTime(startEventEpoch);

smartInterval.SetStartEpoch(accessStartEpoch);


IAgCrdnEventSmartEpoch accessStopEpoch = smartInterval.GetStopEpoch();

accessStopEpoch.SetImplicitTime(stopEventEpoch);

smartInterval.SetStopEpoch(accessStopEpoch);

Convert the start and stop times of the interval into a time.

[C#] Copy Code

// IAgCrdnEventIntervalSmartInterval smartInterval: The time component smart interval


smartInterval.SetStartTimeAndDuration("Now", "+100 day");

object startTime = smartInterval.FindStartTime();

object stopTime = smartInterval.FindStopTime();


Console.WriteLine("StartTime = {0}, StopTime = {1}", startTime, stopTime);

Create and configure explicit smart epoch event.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventSmartEpoch smartEpoch = provider.Events.Factory.CreateSmartEpochFromTime("1 May 2016 04:00:00.000");


// Smart epochs can be set explicitly (Uses current DateTime unit preference, this code snippet assumes UTCG)

smartEpoch.SetExplicitTime("1 May 2015 01:00:00.000");


Console.WriteLine("Event occurred at: " + smartEpoch.TimeInstant);

Create and configure extremum event.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEvent timeEvent = provider.Events.Factory.CreateEventExtremum("MyEventExtremum", "MyDescription");

IAgCrdnEventExtremum asExtremum = timeEvent as IAgCrdnEventExtremum;


// For instance, time at highest altitude

asExtremum.Calculation = provider.CalcScalars["GroundTrajectory.Detic.LLA.Altitude"];

asExtremum.ExtremumType = AgECrdnExtremumConstants.eCrdnExtremumMaximum;


IAgCrdnEventFindOccurrenceResult occurrence = timeEvent.FindOccurrence();

if (occurrence.IsValid)

{

    Console.WriteLine("Event occurred at: " + occurrence.Epoch);

}

Create and configure fixed epoch event.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEvent timeEvent = provider.Events.Factory.CreateEventEpoch("MyEventFixed", "MyDescription");

IAgCrdnEventEpoch asEpoch = timeEvent as IAgCrdnEventEpoch;


// Epoch can be set explicitly (Uses current DateTime unit preference, this code snippet assumes UTCG)

asEpoch.Epoch = "1 May 2016 04:00:00.000";


// Epoch can also be set with the epoch of another event

IAgCrdnEventFindOccurrenceResult startTime = provider.Events["AvailabilityStartTime"].FindOccurrence();

asEpoch.Epoch = startTime.Epoch;


IAgCrdnEventFindOccurrenceResult occurrence = timeEvent.FindOccurrence();

if (occurrence.IsValid)

{

    Console.WriteLine("Event occurred at: " + occurrence.Epoch);

}

Create and configure fixed time offset event.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEvent timeEvent = provider.Events.Factory.CreateEventTimeOffset("MyEventTimeOffset", "MyDescription");

IAgCrdnEventTimeOffset asTimeOffset = timeEvent as IAgCrdnEventTimeOffset;


asTimeOffset.ReferenceTimeInstant = provider.Events["AvailabilityStartTime"];


// Uses current Time unit preference, this code snippet assumes seconds.

asTimeOffset.TimeOffset = 3;


IAgCrdnEventFindOccurrenceResult occurrence = timeEvent.FindOccurrence();

if (occurrence.IsValid)

{

    Console.WriteLine("Event occurred at: " + occurrence.Epoch);

}

Create and configure implicit smart epoch event.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEvent referencedEvent = provider.Events["AvailabilityStartTime"];

IAgCrdnEventSmartEpoch smartEpoch = provider.Events.Factory.CreateSmartEpochFromEvent(referencedEvent);


// Smart epochs can be set implicitly using the another epoch.

IAgCrdnEvent anotherEvent = provider.Events["AvailabilityStopTime"];

smartEpoch.SetImplicitTime(anotherEvent);


Console.WriteLine("Event occurred at: " + smartEpoch.TimeInstant);

Create and configure signaled event.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgCrdnProvider satelliteVgtProvider = stkRoot.GetObjectFromPath("Satellite/LEO").Vgt;

IAgCrdnProvider aircraftVgtProvider = stkRoot.GetObjectFromPath("Aircraft/UAV").Vgt;


IAgCrdnEvent timeEvent = satelliteVgtProvider.Events.Factory.CreateEventSignaled("MyEventSignaled", "MyDescription");

IAgCrdnEventSignaled asSignaled = timeEvent as IAgCrdnEventSignaled;


asSignaled.OriginalTimeInstant = aircraftVgtProvider.Events["EphemerisStartTime"];

asSignaled.BaseClockLocation = satelliteVgtProvider.Points["Center"];

asSignaled.TargetClockLocation = aircraftVgtProvider.Points["Center"];


asSignaled.SignalSense = AgECrdnSignalSense.eCrdnSignalSenseTransmit;

IAgCrdnSignalDelayBasic basicSignalDelay = asSignaled.SignalDelay as IAgCrdnSignalDelayBasic;

basicSignalDelay.SpeedOption = AgECrdnSpeedOptions.eCrdnCustomTransmissionSpeed;


// Uses current Time unit preference, this code snippet assumes seconds.

basicSignalDelay.TimeDelayConvergence = 0.002;


IAgCrdnEventFindOccurrenceResult occurrence = timeEvent.FindOccurrence();

if (occurrence.IsValid)

{

    Console.WriteLine("Event occurred at: " + occurrence.Epoch);

}

Create and configure start stop time event.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEvent timeEvent = provider.Events.Factory.CreateEventStartStopTime("MyEventStartStopTime", "MyDescription");

IAgCrdnEventStartStopTime asStartStopTime = timeEvent as IAgCrdnEventStartStopTime;


asStartStopTime.ReferenceEventInterval = provider.EventIntervals["EphemerisTimeSpan"];


asStartStopTime.UseStart = true;


IAgCrdnEventFindOccurrenceResult occurrence = timeEvent.FindOccurrence();

if (occurrence.IsValid)

{

    Console.WriteLine("Event occurred at: " + occurrence.Epoch);

}

Determine if event occurs before an epoch.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// The event you are interested in.

IAgCrdnEvent timeEvent1 = provider.Events["GroundTrajectory.Detic.LLA.Altitude.TimeOfMax"];


// The reference event you want to determine if event of interest happened before.

IAgCrdnEvent timeEvent2 = provider.Events["GroundTrajectory.Detic.LLA.Altitude.TimeOfMin"];

IAgCrdnEventFindOccurrenceResult occurrence2 = timeEvent2.FindOccurrence();


if (occurrence2.IsValid)

{

    if (timeEvent1.OccursBefore(occurrence2.Epoch))

    {

        Console.WriteLine("The time of maximum altitude happend before time of minimum altitude");

    }

    else

    {

        Console.WriteLine("The time of minimum altitude happend before time of maximum altitude");

    }

}

Determine if the specified event type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnEventType eventType: A event type.


// Check if the specified event type is supported.

if (provider.Events.Factory.IsTypeSupported(eventType))

{

    //Create an Event with the supported Type

    IAgCrdnEvent @event = provider.Events.Factory.Create(

        "MyEvent", string.Empty,

        eventType);

}

Determine the time of an event.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEvent timeEvent = provider.Events["PassIntervals.First.Start"];


IAgCrdnEventFindOccurrenceResult occurrence = timeEvent.FindOccurrence();


if (occurrence.IsValid)

{

    Console.WriteLine("The first pass interval happened at: " + occurrence.Epoch);

}

else

{

    Console.WriteLine("The first pass interval never occurred");

}

Enumerate the existing events.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing events.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing event with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the event with specified name exists

if (provider.Events.Contains("EventName"))

{

    provider.Events.Remove("EventName");

}

Sets the start and stop epoch time with smart epochs.

[C#] Copy Code

// IAgCrdnEventIntervalSmartInterval smartInterval: Event Smart Interval


smartInterval.SetExplicitInterval("Today", "Tomorrow");

Check whether an event array with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if an event array with the specified name already exists.

if (provider.EventArrays.Contains("EventArrayName"))

{

    Console.WriteLine("The event array \"{0}\" already exists!", "EventArrayName");

}

Create and configure condition crossings event array.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventArray eventArray = provider.EventArrays.Factory.CreateEventArrayConditionCrossings("MyEventArrayConditionCrossings", "MyDescription");

IAgCrdnEventArrayConditionCrossings asConditionCrossings = eventArray as IAgCrdnEventArrayConditionCrossings;


IAgCrdnCondition scalarBound = provider.Conditions.Factory.CreateConditionScalarBounds("Bound", "MyDescription");

IAgCrdnConditionScalarBounds asScalarBounds = scalarBound as IAgCrdnConditionScalarBounds;

asScalarBounds.Scalar = provider.CalcScalars["GroundTrajectory.Detic.LLA.Latitude"];

asScalarBounds.Operation = AgECrdnConditionThresholdOption.eCrdnConditionThresholdOptionInsideMinMax;

//asScalarBounds.Set(-0.349, 0);


asConditionCrossings.Condition = scalarBound;


IAgCrdnFindTimesResult timeArrays = eventArray.FindTimes();

if (timeArrays.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = timeArrays.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        Console.WriteLine(timeArrays.Times.GetValue(i));

    }


    foreach (IAgCrdnInterval timeArray in timeArrays.Intervals)

    {

        Console.WriteLine("Start: " + timeArray.Start);

        Console.WriteLine("Stop: " + timeArray.Stop);

    }

}

Create and configure extrema event array.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventArray eventArray = provider.EventArrays.Factory.CreateEventArrayExtrema("MyEventArrayExtrema",  "MyDescription");

IAgCrdnEventArrayExtrema asExtrema = eventArray as IAgCrdnEventArrayExtrema;


asExtrema.Calculation = provider.CalcScalars["GroundTrajectory.Detic.LLA.Altitude"];


asExtrema.IsGlobal = true;

asExtrema.ExtremumType = AgECrdnExtremumConstants.eCrdnExtremumMaximum;


IAgCrdnFindTimesResult timeArrays = eventArray.FindTimes();

if (timeArrays.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = timeArrays.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        Console.WriteLine(timeArrays.Times.GetValue(i));

    }


    foreach (IAgCrdnInterval timeArray in timeArrays.Intervals)

    {

        Console.WriteLine("Start: " + timeArray.Start);

        Console.WriteLine("Stop: " + timeArray.Stop);

    }

}

Create and configure filtered event array.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventArray eventArray = provider.EventArrays.Factory.CreateEventArrayFiltered("MyEventArrayFiltered",  "MyDescription");

IAgCrdnEventArrayFiltered asFiltered = eventArray as IAgCrdnEventArrayFiltered;


asFiltered.OriginalTimeArray = provider.EventArrays["EphemerisTimes"];


asFiltered.FilterType = AgECrdnEventArrayFilterType.eCrdnEventArrayFilterTypeSkipTimeStep;

asFiltered.IncludeIntervalStopTimes = true;


// Uses current Time unit preference, this code snippet assumes seconds.

asFiltered.Step = 240;


IAgCrdnFindTimesResult timeArrays = eventArray.FindTimes();

if (timeArrays.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = timeArrays.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        Console.WriteLine(timeArrays.Times.GetValue(i));

    }


    foreach (IAgCrdnInterval timeArray in timeArrays.Intervals)

    {

        Console.WriteLine("Start: " + timeArray.Start);

        Console.WriteLine("Stop: " + timeArray.Stop);

    }

}

Create and configure fixed step event array.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventArray eventArray = provider.EventArrays.Factory.CreateEventArrayFixedStep("MyEventArrayFixedStep",  "MyDescription");

IAgCrdnEventArrayFixedStep asFixedStep = eventArray as IAgCrdnEventArrayFixedStep;


asFixedStep.BoundingIntervalList = provider.EventIntervalLists["AfterStart.SatisfactionIntervals"];

asFixedStep.IncludeIntervalEdges = true;


// Uses current Time unit preference, this code snippet assumes seconds.

asFixedStep.SamplingTimeStep = 240;

asFixedStep.ReferenceType = AgECrdnSampledReferenceTime.eCrdnSampledReferenceTimeStartOfIntervalList;


// or using time instants

asFixedStep.ReferenceType = AgECrdnSampledReferenceTime.eCrdnSampledReferenceTimeReferenceEvent;

asFixedStep.ReferenceTimeInstant = provider.Events["EphemerisStartTime"];


IAgCrdnFindTimesResult timeArrays = eventArray.FindTimes();

if (timeArrays.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = timeArrays.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        Console.WriteLine(timeArrays.Times.GetValue(i));

    }


    foreach (IAgCrdnInterval timeArray in timeArrays.Intervals)

    {

        Console.WriteLine("Start: " + timeArray.Start);

        Console.WriteLine("Stop: " + timeArray.Stop);

    }

}

Create and configure merged event array.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventArray eventArray = provider.EventArrays.Factory.CreateEventArrayMerged("MyEventArrayMerged",  "MyDescription");

IAgCrdnEventArrayMerged asMerged = eventArray as IAgCrdnEventArrayMerged;


asMerged.TimeArrayA = provider.EventArrays["GroundTrajectory.Detic.LLA.Altitude.TimesOfLocalMin"];

asMerged.TimeArrayB = provider.EventArrays["GroundTrajectory.Detic.LLA.Altitude.TimesOfLocalMax"];


IAgCrdnFindTimesResult timeArrays = eventArray.FindTimes();

if (timeArrays.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = timeArrays.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        Console.WriteLine(timeArrays.Times.GetValue(i));

    }


    foreach (IAgCrdnInterval timeArray in timeArrays.Intervals)

    {

        Console.WriteLine("Start: " + timeArray.Start);

        Console.WriteLine("Stop: " + timeArray.Stop);

    }

}

Create and configure signaled event array.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgCrdnProvider satelliteVgtProvider = stkRoot.GetObjectFromPath("Satellite/LEO").Vgt;

IAgCrdnProvider aircraftVgtProvider = stkRoot.GetObjectFromPath("Aircraft/UAV").Vgt;


IAgCrdnEventArray eventArray = satelliteVgtProvider.EventArrays.Factory.CreateEventArraySignaled("MyEventArraySignaled",  "MyDescription");

IAgCrdnEventArraySignaled asSignaled = eventArray as IAgCrdnEventArraySignaled;


asSignaled.OriginalTimeArray = aircraftVgtProvider.EventArrays["OneMinuteSampleTimes"];

asSignaled.BaseClockLocation = satelliteVgtProvider.Points["Center"];

asSignaled.TargetClockLocation = aircraftVgtProvider.Points["Center"];


asSignaled.SignalSense = AgECrdnSignalSense.eCrdnSignalSenseTransmit;

IAgCrdnSignalDelayBasic basicSignalDelay = asSignaled.SignalDelay as IAgCrdnSignalDelayBasic;

basicSignalDelay.SpeedOption = AgECrdnSpeedOptions.eCrdnLightTransmissionSpeed;


// Uses current Time unit preference, this code snippet assumes seconds.

basicSignalDelay.TimeDelayConvergence = 0.01;


IAgCrdnFindTimesResult timeArrays = eventArray.FindTimes();

if (timeArrays.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = timeArrays.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        Console.WriteLine(timeArrays.Times.GetValue(i));

    }


    foreach (IAgCrdnInterval timeArray in timeArrays.Intervals)

    {

        Console.WriteLine("Start: " + timeArray.Start);

        Console.WriteLine("Stop: " + timeArray.Stop);

    }

}

Create and configure start stop times event array.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventArray eventArray = provider.EventArrays.Factory.CreateEventArrayStartStopTimes("MyEventArrayStartStopTimes",  "MyDescription");

IAgCrdnEventArrayStartStopTimes asStartStopTimes = eventArray as IAgCrdnEventArrayStartStopTimes;


asStartStopTimes.ReferenceIntervals = provider.EventIntervalLists["LightingIntervals.Sunlight"];

asStartStopTimes.StartStopOption = AgECrdnStartStopOption.eCrdnStartStopOptionCountStartOnly;


IAgCrdnFindTimesResult timeArrays = eventArray.FindTimes();

if (timeArrays.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = timeArrays.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        Console.WriteLine(timeArrays.Times.GetValue(i));

    }


    foreach (IAgCrdnInterval timeArray in timeArrays.Intervals)

    {

        Console.WriteLine("Start: " + timeArray.Start);

        Console.WriteLine("Stop: " + timeArray.Stop);

    }

}

Determine altitude of aircraft at one minute samples.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


// Get the aircraft

IAgStkObject aircraft = stkRoot.GetObjectFromPath("Aircraft/UAV");


// Configure a fixed step array that samples every 20 seconds.

IAgCrdnEventArray twentySecondSample = aircraft.Vgt.EventArrays.Factory.CreateEventArrayFixedStep("TwentySecondSample",  "MyDescription");

IAgCrdnEventArrayFixedStep asFixedStep = twentySecondSample as IAgCrdnEventArrayFixedStep;

asFixedStep.BoundingIntervalList = aircraft.Vgt.EventIntervalLists["AvailabilityIntervals"];

asFixedStep.SamplingTimeStep = 20;

asFixedStep.ReferenceType = AgECrdnSampledReferenceTime.eCrdnSampledReferenceTimeStartOfIntervalList;


// At each time step, get the aircraft's altitude and print the value.

IAgCrdnFindTimesResult timeArrays = twentySecondSample.FindTimes();

if (timeArrays.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = timeArrays.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        object epoch = timeArrays.Times.GetValue(i);

        Array altitueAtTime = aircraft.Vgt.CalcScalars["GroundTrajectory.Detic.LLA.Altitude"].QuickEvaluate(epoch);

        if ((bool)altitueAtTime.GetValue(0) == true)

        {

            Console.WriteLine("{0}: {1}", epoch, altitueAtTime.GetValue(1));

        }

    }

}

Determine if the specified event array type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnEventArrayType eventArrayType: A event array type.


// Check if the specified event array type is supported.

if (provider.EventArrays.Factory.IsTypeSupported(eventArrayType))

{

    //Create an EventArray with the supported Type

    IAgCrdnEventArray eventArray = provider.EventArrays.Factory.Create(

        "MyEventArray", string.Empty,

        eventArrayType);

}

Determines the time intervals of an event array.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventArray eventArray = provider.EventArrays["Orbit.Classical.SemimajorAxis.TimesOfLocalMax"];


IAgCrdnFindTimesResult foundTimes = eventArray.FindTimes();

if (foundTimes.IsValid)

{

    Console.WriteLine("Times");

    int numTimes = foundTimes.Times.GetLength(0);

    for (int i = 0; i < numTimes; ++i)

    {

        Console.WriteLine(foundTimes.Times.GetValue(i));

    }


    foreach (IAgCrdnInterval timeArray in foundTimes.Intervals)

    {

        Console.WriteLine("Start: " + timeArray.Start);

        Console.WriteLine("Stop: " + timeArray.Stop);

    }

}

Enumerate the existing event arrays.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing event arrays.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing event array with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the event array with specified name exists

if (provider.EventArrays.Contains("EventArrayName"))

{

    provider.EventArrays.Remove("EventArrayName");

}

Check whether an event interval with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if an event interval with the specified name already exists.

if (provider.EventIntervals.Contains("EventIntervalName"))

{

    Console.WriteLine("The event interval \"{0}\" already exists!", "EventIntervalName");

}

Create and configure event interval between two instants.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventInterval eventInterval = provider.EventIntervals.Factory.CreateEventIntervalBetweenTimeInstants("MyIntervalBetweenTwoInstants",  "MyDescription");

IAgCrdnEventIntervalBetweenTimeInstants asTimeInstant = eventInterval as IAgCrdnEventIntervalBetweenTimeInstants;


asTimeInstant.StartTimeInstant = provider.Events["EphemerisStartTime"];

asTimeInstant.StopTimeInstant = provider.Events["EphemerisStopTime"];


IAgCrdnEventIntervalResult intervalResult = eventInterval.FindInterval();

if (intervalResult.IsValid)

{

    Console.WriteLine("Interval Start: " + intervalResult.Interval.Start);

    Console.WriteLine("Interval Stop: " + intervalResult.Interval.Stop);

}

Create and configure event interval from an interval list.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventInterval eventInterval = provider.EventIntervals.Factory.CreateEventIntervalFromIntervalList("MyIntervalList",  "MyDescription");

IAgCrdnEventIntervalFromIntervalList asIntervalList = eventInterval as IAgCrdnEventIntervalFromIntervalList;


asIntervalList.ReferenceIntervals = provider.EventIntervalLists["AttitudeIntervals"];

asIntervalList.IntervalSelection = AgECrdnIntervalSelection.eCrdnIntervalSelectionMaxGap;


// Or from start...

asIntervalList.IntervalSelection = AgECrdnIntervalSelection.eCrdnIntervalSelectionFromStart;

asIntervalList.IntervalNumber = 1;


IAgCrdnEventIntervalResult intervalResult = eventInterval.FindInterval();

if (intervalResult.IsValid)

{

    Console.WriteLine("Interval Start: " + intervalResult.Interval.Start);

    Console.WriteLine("Interval Stop: " + intervalResult.Interval.Stop);

}

Create and configure fixed duration event interval.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventInterval eventInterval = provider.EventIntervals.Factory.CreateEventIntervalFixedDuration("MyIntervalFixedDuration",  "MyDescription");

IAgCrdnEventIntervalFixedDuration asFixedDuration = eventInterval as IAgCrdnEventIntervalFixedDuration;


asFixedDuration.ReferenceTimeInstant = provider.Events["AvailabilityStartTime"];


// Uses current Time unit preference, this code snippet assumes seconds.

asFixedDuration.StartOffset = 10;


// Uses current Time unit preference, this code snippet assumes seconds.

asFixedDuration.StopOffset = 360;


IAgCrdnEventIntervalResult intervalResult = eventInterval.FindInterval();

if (intervalResult.IsValid)

{

    Console.WriteLine("Interval Start: " + intervalResult.Interval.Start);

    Console.WriteLine("Interval Stop: " + intervalResult.Interval.Stop);

}

Create and configure fixed event interval.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventInterval eventInterval = provider.EventIntervals.Factory.CreateEventIntervalFixed("MyIntervalFixed",  "MyDescription");

IAgCrdnEventIntervalFixed asFixed = eventInterval as IAgCrdnEventIntervalFixed;


asFixed.SetInterval(

    provider.Events["AvailabilityStartTime"].FindOccurrence().Epoch,

    provider.Events["AvailabilityStopTime"].FindOccurrence().Epoch);


IAgCrdnEventIntervalResult intervalResult = eventInterval.FindInterval();

if (intervalResult.IsValid)

{

    Console.WriteLine("Interval Start: " + intervalResult.Interval.Start);

    Console.WriteLine("Interval Stop: " + intervalResult.Interval.Stop);

}

Create and configure scaled event interval.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventInterval eventInterval = provider.EventIntervals.Factory.CreateEventIntervalScaled("MyIntervalScaled",  "MyDescription");

IAgCrdnEventIntervalScaled asScaled = eventInterval as IAgCrdnEventIntervalScaled;


asScaled.OriginalInterval = provider.EventIntervals["AvailabilityTimeSpan"];


asScaled.AbsoluteIncrement = 30;


// Or use Relative

asScaled.UseAbsoluteIncrement = false;

asScaled.RelativeIncrement = 45; // Percentage


IAgCrdnEventIntervalResult intervalResult = eventInterval.FindInterval();

if (intervalResult.IsValid)

{

    Console.WriteLine("Interval Start: " + intervalResult.Interval.Start);

    Console.WriteLine("Interval Stop: " + intervalResult.Interval.Stop);

}

Create and configure signaled event interval.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgCrdnProvider satelliteVgtProvider = stkRoot.GetObjectFromPath("Satellite/LEO").Vgt;

IAgCrdnProvider aircraftVgtProvider = stkRoot.GetObjectFromPath("Aircraft/UAV").Vgt;


IAgCrdnEventInterval eventInterval = satelliteVgtProvider.EventIntervals.Factory.CreateEventIntervalSignaled("MyIntervalSignaled",  "MyDescription");

IAgCrdnEventIntervalSignaled asSignaled = eventInterval as IAgCrdnEventIntervalSignaled;


asSignaled.OriginalInterval = aircraftVgtProvider.EventIntervals["AvailabilityTimeSpan"];

asSignaled.BaseClockLocation = satelliteVgtProvider.Points["Center"];

asSignaled.TargetClockLocation = aircraftVgtProvider.Points["Center"];


asSignaled.SignalSense = AgECrdnSignalSense.eCrdnSignalSenseReceive;

IAgCrdnSignalDelayBasic basicSignalDelay = asSignaled.SignalDelay as IAgCrdnSignalDelayBasic;

basicSignalDelay.SpeedOption = AgECrdnSpeedOptions.eCrdnLightTransmissionSpeed;


// Uses current Time unit preference, this code snippet assumes seconds.

basicSignalDelay.TimeDelayConvergence = 0.002;


IAgCrdnEventIntervalResult intervalResult = eventInterval.FindInterval();

if (intervalResult.IsValid)

{

    Console.WriteLine("Interval Start: " + intervalResult.Interval.Start);

    Console.WriteLine("Interval Stop: " + intervalResult.Interval.Stop);

}

Create and configure time offset event interval.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventInterval eventInterval = provider.EventIntervals.Factory.CreateEventIntervalTimeOffset("MyIntervalFixedTimeOffset",  "MyDescription");

IAgCrdnEventIntervalTimeOffset asFixedTimeOffset = eventInterval as IAgCrdnEventIntervalTimeOffset;


asFixedTimeOffset.ReferenceInterval = provider.EventIntervals["AvailabilityTimeSpan"];


// Uses current Time unit preference, this code snippet assumes seconds.

asFixedTimeOffset.TimeOffset = 30;


IAgCrdnEventIntervalResult intervalResult = eventInterval.FindInterval();

if (intervalResult.IsValid)

{

    Console.WriteLine("Interval Start: " + intervalResult.Interval.Start);

    Console.WriteLine("Interval Stop: " + intervalResult.Interval.Stop);

}

Determine if event occurred in interval.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// The event you are interested in.

IAgCrdnEventInterval timeEventInterval = provider.EventIntervals["LightingIntervals.Sunlight.First"];


// The reference event you want to determine if event occurred in the interval.

IAgCrdnEvent timeEvent = provider.Events["GroundTrajectory.Detic.LLA.Altitude.TimeOfMax"];

IAgCrdnEventFindOccurrenceResult occurrence = timeEvent.FindOccurrence();


if (occurrence.IsValid)

{

    if (timeEventInterval.Occurred(occurrence.Epoch))

    {

        Console.WriteLine("Our highest altitude was reached on the first lighting pass");

    }

    else

    {

        Console.WriteLine("Our highest altitude was not reached on the first lighting pass");

    }

}

Determine if the specified event interval type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnEventIntervalType eventIntervalType: A event interval type.


// Check if the specified event interval type is supported.

if (provider.EventIntervals.Factory.IsTypeSupported(eventIntervalType))

{

    //Create an EventInterval with the supported Type

    IAgCrdnEventInterval eventInterval = provider.EventIntervals.Factory.Create(

        "MyEventInterval", string.Empty,

        eventIntervalType);

}

Determines the start and stop times of the event interval.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventInterval eventInterval = provider.EventIntervals["AvailabilityTimeSpan"];


IAgCrdnEventIntervalResult interval = eventInterval.FindInterval();


if (interval.IsValid)

{

    Console.WriteLine("Interval Start: " + interval.Interval.Start);

    Console.WriteLine("Interval Stop: " + interval.Interval.Stop);

}

Enumerate the existing event intervals.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing event intervals.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing event interval with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the event interval with specified name exists

if (provider.EventIntervals.Contains("EventIntervalName"))

{

    provider.EventIntervals.Remove("EventIntervalName");

}

Check whether an event interval collection with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if an event interval collection with the specified name already exists.

if (provider.EventIntervalCollections.Contains("EventIntervalCollectionName"))

{

    Console.WriteLine("The event interval collection \"{0}\" already exists!", "EventIntervalCollectionName");

}

Create and configure lighting event interval collection.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalCollection intervalCollection = provider.EventIntervalCollections.Factory.CreateEventIntervalCollectionLighting("MyIntervalCollectionLightning",  "MyDescription");

IAgCrdnEventIntervalCollectionLighting asCollectionLightning = intervalCollection as IAgCrdnEventIntervalCollectionLighting;


// Optionally use a separate central body

asCollectionLightning.UseObjectEclipsingBodies = true;

asCollectionLightning.Location = provider.Points["Center"];

asCollectionLightning.EclipsingBodies = new object[] { "Saturn", "Jupiter" };


IAgCrdnIntervalsVectorResult intervalResult = intervalCollection.FindIntervalCollection();

if (intervalResult.IsValid)

{

    foreach (IAgCrdnIntervalCollection intervals in intervalResult.IntervalCollections)

    {

        foreach (IAgCrdnInterval interval in intervals)

        {

            Console.WriteLine("Start: " + interval.Start);

            Console.WriteLine("Start: " + interval.Stop);

        }

    }

}

Create and configure signaled event interval collection.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgCrdnProvider satelliteVgtProvider = stkRoot.GetObjectFromPath("Satellite/LEO").Vgt;

IAgCrdnProvider aircraftVgtProvider = stkRoot.GetObjectFromPath("Aircraft/UAV").Vgt;


IAgCrdnEventIntervalCollection intervalCollection = satelliteVgtProvider.EventIntervalCollections.Factory.CreateEventIntervalCollectionSignaled("MyIntervalCollectionSignaled",  "MyDescription");

IAgCrdnEventIntervalCollectionSignaled asCollectionSignaled = intervalCollection as IAgCrdnEventIntervalCollectionSignaled;


asCollectionSignaled.OriginalCollection = aircraftVgtProvider.EventIntervalCollections["LightingIntervals"];

asCollectionSignaled.BaseClockLocation = satelliteVgtProvider.Points["Center"];

asCollectionSignaled.TargetClockLocation = aircraftVgtProvider.Points["Center"];


asCollectionSignaled.SignalSense = AgECrdnSignalSense.eCrdnSignalSenseTransmit;

IAgCrdnSignalDelayBasic basicSignalDelay = asCollectionSignaled.SignalDelay as IAgCrdnSignalDelayBasic;

basicSignalDelay.SpeedOption = AgECrdnSpeedOptions.eCrdnLightTransmissionSpeed;


// Uses current Time unit preference, this code snippet assumes seconds.

basicSignalDelay.TimeDelayConvergence = 0.002;


IAgCrdnIntervalsVectorResult intervalResult = intervalCollection.FindIntervalCollection();

if (intervalResult.IsValid)

{

    foreach (IAgCrdnIntervalCollection intervals in intervalResult.IntervalCollections)

    {

        foreach (IAgCrdnInterval interval in intervals)

        {

            Console.WriteLine("Start: " + interval.Start);

            Console.WriteLine("Start: " + interval.Stop);

        }

    }

}

Determine if epoch occurred in interval collection.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalCollection intervalVectorCollection = provider.EventIntervalCollections["LightingIntervals"];


IAgCrdnEventIntervalCollectionOccurredResult occurredResult = intervalVectorCollection.Occurred("1 May 2015 04:30:00.000");


if (occurredResult.IsValid)

{

    Console.WriteLine("Occurred at {0} index", occurredResult.Index);


    // Use the index from IAgCrdnEventIntervalCollectionOccurredResult as the index to IAgCrdnIntervalsVectorResult.IntervalCollections

    IAgCrdnIntervalsVectorResult intervalResult = intervalVectorCollection.FindIntervalCollection();

    IAgCrdnIntervalCollection intervalCollection = intervalResult.IntervalCollections[occurredResult.Index];

}

Determine if the specified event interval collection type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnEventIntervalCollectionType eventIntervalCollectionType: A event interval collection type.


// Check if the specified event interval collection type is supported.

if (provider.EventIntervalCollections.Factory.IsTypeSupported(eventIntervalCollectionType))

{

    //Create an EventIntervalCollection with the supported Type

    IAgCrdnEventIntervalCollection eventIntervalCollection = provider.EventIntervalCollections.Factory.Create(

        "MyEventIntervalCollection", string.Empty,

        eventIntervalCollectionType);

}

Determines the event intervals contained in the interval collection.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalCollection intervalCollection = provider.EventIntervalCollections["LightingIntervals"];


IAgCrdnIntervalsVectorResult intervalResult = intervalCollection.FindIntervalCollection();

if (intervalResult.IsValid)

{

    foreach (IAgCrdnIntervalCollection intervals in intervalResult.IntervalCollections)

    {

        foreach (IAgCrdnInterval interval in intervals)

        {

            Console.WriteLine("Start: " + interval.Start);

            Console.WriteLine("Start: " + interval.Stop);

        }

    }

}

Enumerate the existing event interval collections.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing event interval collections.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing event interval collection with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the event interval collection with specified name exists

if (provider.EventIntervalCollections.Contains("EventIntervalCollectionName"))

{

    provider.EventIntervalCollections.Remove("EventIntervalCollectionName");

}

Check whether an event interval list with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if an event interval list with the specified name already exists.

if (provider.EventIntervalLists.Contains("EventIntervalListName"))

{

    Console.WriteLine("The event interval list \"{0}\" already exists!", "EventIntervalListName");

}

Create and configure event interval list from file.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider

// String intervalFile: Path to interval file.


// Example contents of a file

//

//  STK.V.10.0

//

//  BEGIN IntervalList

//      ScenarioEpoch 1 Jul 1999 00:00:00.00

//      DATEUNITABRV UTCG

//

//  BEGIN Intervals

//      "1 Jul 1999 00:00:00.00" "1 Jul 1999 02:00:00.00"

//      "1 Jul 1999 05:00:00.00" "1 Jul 1999 07:00:00.00"

//      "1 Jul 1999 11:00:00.00" "1 Jul 1999 13:00:00.00"

//      "1 Jul 1999 17:00:00.00" "1 Jul 1999 19:00:00.00"

//  END Intervals

//

//  END IntervalList


IAgCrdnEventIntervalList intervalList = provider.EventIntervalLists.Factory.CreateEventIntervalListFile("MyIntervalListFromFile", "MyDescription", intervalFile);

IAgCrdnEventIntervalListFile asListFile = intervalList as IAgCrdnEventIntervalListFile;


IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Create and configure filtered event interval list.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalList intervalList = provider.EventIntervalLists.Factory.CreateEventIntervalListFiltered("MyIntervalListFiltered",  "MyDescription");

IAgCrdnEventIntervalListFiltered listFiltered = intervalList as IAgCrdnEventIntervalListFiltered;


listFiltered.OriginalIntervals = provider.EventIntervalLists["AttitudeIntervals"];


IAgCrdnFirstIntervalsFilter firstIntervals = listFiltered.FilterFactory.Create(AgECrdnPruneFilter.eCrdnPruneFilterFirstIntervals) as IAgCrdnFirstIntervalsFilter;

firstIntervals.MaximumNumberOfIntervals = 3;


// Or for example satisfaction intervals

IAgCrdnSatisfactionConditionFilter asSatisfactionCondition = listFiltered.FilterFactory.Create(AgECrdnPruneFilter.eCrdnPruneFilterSatisfactionIntervals) as IAgCrdnSatisfactionConditionFilter;

asSatisfactionCondition.Condition = provider.Conditions["BeforeStop"];

asSatisfactionCondition.DurationKind = AgECrdnIntervalDurationKind.eCrdnIntervalDurationKindAtLeast;


// Uses current Time unit preference, this code snippet assumes seconds.

asSatisfactionCondition.IntervalDuration = 30;


IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Create and configure list condition event interval.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalList intervalList = provider.EventIntervalLists.Factory.CreateEventIntervalListCondition("MyIntervalListSatisfaction",  "MyDescription");

IAgCrdnEventIntervalListCondition asListCondition = intervalList as IAgCrdnEventIntervalListCondition;


asListCondition.Condition = provider.Conditions["AfterStart"];


IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Create and configure merged event interval list.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgCrdnProvider satelliteVgtProvider = stkRoot.GetObjectFromPath("Satellite/LEO").Vgt;

IAgCrdnProvider aircraftVgtProvider = stkRoot.GetObjectFromPath("Aircraft/UAV").Vgt;


IAgCrdnEventIntervalList intervalList = satelliteVgtProvider.EventIntervalLists.Factory.CreateEventIntervalListMerged("MyIntervalListMerged",  "MyDescription");

IAgCrdnEventIntervalListMerged asListMerged = intervalList as IAgCrdnEventIntervalListMerged;


asListMerged.SetIntervalListA(satelliteVgtProvider.EventIntervalLists["AvailabilityIntervals"]);

asListMerged.SetIntervalListB(aircraftVgtProvider.EventIntervalLists["AvailabilityIntervals"]);

asListMerged.MergeOperation = AgECrdnEventListMergeOperation.eCrdnEventListMergeOperationMINUS;


IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Create and configure scaled event interval list.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalList intervalList = provider.EventIntervalLists.Factory.CreateEventIntervalListScaled("MyIntervalListScaled",  "MyDescription");

IAgCrdnEventIntervalListScaled asListScaled = intervalList as IAgCrdnEventIntervalListScaled;


asListScaled.AbsoluteIncrement = 40;


// Or use Relative

asListScaled.UseAbsoluteIncrement = false;

asListScaled.RelativeIncrement = 20; // Percentage


IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Create and configure signaled event interval list.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgCrdnProvider satelliteVgtProvider = stkRoot.GetObjectFromPath("Satellite/LEO").Vgt;

IAgCrdnProvider aircraftVgtProvider = stkRoot.GetObjectFromPath("Aircraft/UAV").Vgt;


IAgCrdnEventIntervalList intervalList = satelliteVgtProvider.EventIntervalLists.Factory.CreateEventIntervalListSignaled("MyIntervalListSignaled",  "MyDescription");

IAgCrdnEventIntervalListSignaled asListSingled = intervalList as IAgCrdnEventIntervalListSignaled;


asListSingled.OriginalIntervals = aircraftVgtProvider.EventIntervalLists["BeforeStop.SatisfactionIntervals"];

asListSingled.BaseClockLocation = satelliteVgtProvider.Points["Center"];

asListSingled.TargetClockLocation = aircraftVgtProvider.Points["Center"];


asListSingled.SignalSense = AgECrdnSignalSense.eCrdnSignalSenseTransmit;

IAgCrdnSignalDelayBasic basicSignalDelay = asListSingled.SignalDelay as IAgCrdnSignalDelayBasic;

basicSignalDelay.SpeedOption = AgECrdnSpeedOptions.eCrdnCustomTransmissionSpeed;


// Uses current Time unit preference, this code snippet assumes seconds.

basicSignalDelay.TimeDelayConvergence = 0.002;


IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Create and configure time offset event interval list.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalList intervalList = provider.EventIntervalLists.Factory.CreateEventIntervalListTimeOffset("MyIntervalListFixedTimeOffset",  "MyDescription");

IAgCrdnEventIntervalListTimeOffset asTimeOffset = intervalList as IAgCrdnEventIntervalListTimeOffset;


asTimeOffset.ReferenceIntervals = provider.EventIntervalLists["AfterStart.SatisfactionIntervals"];


// Uses current Time unit preference, this code snippet assumes seconds.

asTimeOffset.TimeOffset = 300;


IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Determine if epoch occured in interval collection.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalList intervalList = provider.EventIntervalLists["AttitudeIntervals"];


// The reference event you want to determine if event of interest happened before.

IAgCrdnEvent timeEvent = provider.Events["GroundTrajectory.Detic.LLA.Altitude.TimeOfMin"];

IAgCrdnEventFindOccurrenceResult occurrence = timeEvent.FindOccurrence();


if (intervalList.Occurred(occurrence.Epoch))

{

    Console.WriteLine("The time of maximum altitude occurred in event interval list.");

}

else

{

    Console.WriteLine("The time of maximum altitude did not occurred in event interval list.");

}

Determine if the specified event interval list type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnEventIntervalListType eventIntervalListType: A event interval list type.


// Check if the specified event interval list type is supported.

if (provider.EventIntervalLists.Factory.IsTypeSupported(eventIntervalListType))

{

    //Create an EventIntervalList with the supported Type

    IAgCrdnEventIntervalList eventIntervalList = provider.EventIntervalLists.Factory.Create(

        "MyEventIntervalList", string.Empty,

        eventIntervalListType);

}

Determine the intervals an aircraft is above a certain velocity.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


IAgCrdnProvider aircraftVgtProvider = stkRoot.GetObjectFromPath("Aircraft/UAV").Vgt;


IAgCrdnEventIntervalList intervalList = aircraftVgtProvider.EventIntervalLists.Factory.CreateEventIntervalListCondition("IntervalsAboveCertainVelocity",  "MyDescription");

IAgCrdnEventIntervalListCondition asListCondition = intervalList as IAgCrdnEventIntervalListCondition;


IAgCrdnCondition aboveBoundCondition = aircraftVgtProvider.Conditions.Factory.CreateConditionScalarBounds("AboveCertainBound", "MyDescription");

IAgCrdnConditionScalarBounds asScalarBounds = aboveBoundCondition as IAgCrdnConditionScalarBounds;

asScalarBounds.Operation = AgECrdnConditionThresholdOption.eCrdnConditionThresholdOptionAboveMin;

asScalarBounds.Scalar = aircraftVgtProvider.CalcScalars["Trajectory(CBI).Cartesian.Z"];

//asScalarBounds.Minimum = 4082;


asListCondition.Condition = aboveBoundCondition;


IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Determine the intervals without access.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root


// Compute UAV's access to the satellite

IAgStkObject satellite = stkRoot.GetObjectFromPath("Satellite/LEO");

IAgStkObject aircraft = stkRoot.GetObjectFromPath("Aircraft/UAV");

IAgStkAccess satelliteAccess = aircraft.GetAccessToObject(satellite);

satelliteAccess.ComputeAccess();


// Subtract the aircraft availability time with the access times to get the times without access.

IAgCrdnEventIntervalList intervalList = aircraft.Vgt.EventIntervalLists.Factory.CreateEventIntervalListMerged("IntervalsWithoutAccess",  "MyDescription");

IAgCrdnEventIntervalListMerged asListMerged = intervalList as IAgCrdnEventIntervalListMerged;

asListMerged.SetIntervalListA(aircraft.Vgt.EventIntervalLists["AvailabilityIntervals"]);

asListMerged.SetIntervalListB(satelliteAccess.Vgt.EventIntervalLists["AccessIntervals"]);

asListMerged.MergeOperation = AgECrdnEventListMergeOperation.eCrdnEventListMergeOperationMINUS;


// Print times without access.

IAgCrdnIntervalListResult intervals = intervalList.FindIntervals();

if (intervals.IsValid)

{

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Start: " + interval.Start);

        Console.WriteLine("Stop: " + interval.Stop);

    }

}

Determines the event intervals contained in the interval list.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


IAgCrdnEventIntervalList intervalsList = provider.EventIntervalLists["AttitudeIntervals"];


IAgCrdnIntervalListResult intervals = intervalsList.FindIntervals();


if (intervals.IsValid)

{

    Console.WriteLine("Intervals:");

    foreach (IAgCrdnInterval interval in intervals.Intervals)

    {

        Console.WriteLine("Interval Start: " + interval.Start);

        Console.WriteLine("Interval Stop: " + interval.Stop);

    }

}

Enumerate the existing event interval lists.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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 existing event interval lists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing event interval list with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the event interval list with specified name exists

if (provider.EventIntervalLists.Contains("EventIntervalListName"))

{

    provider.EventIntervalLists.Remove("EventIntervalListName");

}

Check whether a parameter set with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


//Check if a parameter set with the specified name already exists.

if (provider.ParameterSets.Contains("ParameterSetName"))

{

    Console.WriteLine("The parameter set \"{0}\" already exists!", "ParameterSetName");

}

Create an attitude parameter set.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


//Create an attitude parameter set.

IAgCrdnParameterSetAttitude parameterSet = (IAgCrdnParameterSetAttitude)provider.ParameterSets.Factory.Create(

    "ParameterSetName", "Attitude parameter set.", AgECrdnParameterSetType.eCrdnParameterSetTypeAttitude);

Determine if the specified parameter set type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnParameterSetType parameterSetType: A parameter set type.


// Check if the specified parameter set type is supported.

if (provider.ParameterSets.Factory.IsTypeSupported(parameterSetType))

{

    //Create a ParameterSet with the supported Type

    IAgCrdnParameterSet parameterSet = provider.ParameterSets.Factory.Create(

        "MyParameterSet", string.Empty,

        parameterSetType);

}

Enumerate the existing parameter sets.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing parameter sets.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing parameter set with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the parameter set with specified name exists

if (provider.ParameterSets.Contains("ParameterSetName"))

{

    provider.ParameterSets.Remove("ParameterSetName");

}

Check whether a plane with specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the plane with the specified name already exists.

if (provider.Planes.Contains("PlaneName"))

{

    Console.WriteLine("The plane \"{0}\" already exists!", "PlaneName");

}

Check whether the reference plane has a cyclic dependency on another plane.

[C#] Copy Code

// IAgCrdnPlaneRefTo planeRefTo: Reference to a plane.

// IAgCrdnPlane plane: A plane to check against reference plane.


//Check if the reference plane has a cyclic dependency on another plane.

if (planeRefTo.HasCyclicDependency(plane))

{

    Console.WriteLine("The plane {0} has a cyclic dependency on plane {1}.", ((IAgCrdn)planeRefTo.GetPlane()).Name, ((IAgCrdn)plane).Name);

}

Create a plane normal to vector.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Create a plane normal to vector.

IAgCrdnPlaneNormal p = (IAgCrdnPlaneNormal)provider.Planes.Factory.Create(

    "PlaneName", "A plane normal to vector.", AgECrdnPlaneType.eCrdnPlaneTypeNormal);

Determine if the specified plane type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// AgECrdnPlaneType planeType: A plane type.


// Check if the specified plane type is supported.

if (provider.Planes.Factory.IsTypeSupported(planeType))

{

    IAgCrdnPlane p = provider.Planes.Factory.Create(

        "PlaneName", string.Empty,

        planeType);

}

Enumerate the existing planes.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing planes.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing plane with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the plane with specified name exists

if (provider.Planes.Contains("PlaneName"))

{

    provider.Planes.Remove("PlaneName");

}

Check whether a point with the specified name exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if a point with specified name exists.

if (provider.Points.Contains("PointName"))

{

    Console.WriteLine("The point \"{0}\" exists!", "PointName");

}

Check whether the reference point has a cyclic dependency on another point.

[C#] Copy Code

// IAgCrdnPointRefTo pointRefTo: Reference to a point.

// IAgCrdnPoint point: A point to check against reference point.


//Check if the reference point has a cyclic dependency on another point.

if (pointRefTo.HasCyclicDependency(point))

{

    Console.WriteLine("The point {0} has a cyclic dependency on point {1}.", ((IAgCrdn)pointRefTo.GetPoint()).Name, ((IAgCrdn)point).Name);

}

Create a B-Plane point using selected target body.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// String TargetBody: A target central body


// Create a B-Plane point using selected target body

IAgCrdnPointBPlane point = (IAgCrdnPointBPlane)provider.Points.Factory.Create(

    "PointName", string.Empty, AgECrdnPointType.eCrdnPointTypeBPlane);

point.TargetBody.SetPath(TargetBody);

Determine if the specified point type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// AgECrdnPointType PointType: A point type


// Check if the specified point type is supported.

if (provider.Points.Factory.IsTypeSupported(PointType))

{

    IAgCrdnPoint point = provider.Points.Factory.Create(

        "PointName", string.Empty, PointType);

}

Enumerate the existing points.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through the existing points.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Locates a point in the Earth's Fixed reference frame.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// IAgCrdnPoint point: A valid VGT point object.


IAgCrdnPointLocateInSystemResult result = point.LocateInSystem(0,

    provider.WellKnownSystems.Earth.Fixed);

if (result.IsValid)

{

    Console.WriteLine("The position of the point in Earth's Fixed reference frame: {0},{1},{2}",

        result.Position.X, result.Position.Y, result.Position.Z);

}

Remove an existing point with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the specified point exists

if (provider.Points.Contains("PointName"))

{

    provider.Points.Remove("PointName");

}

Check whether a system with the specified name exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the specified system exists.

if (provider.Systems.Contains("SystemName"))

{

    Console.WriteLine("The system \"{0}\" exists!", "SystemName");

}

Check whether the reference system has a cyclic dependency on another system.

[C#] Copy Code

// IAgCrdnSystemRefTo systemRefTo: Reference to a system.

// IAgCrdnSystem system: A system to check against reference system.


//Check if the reference system has a cyclic dependency on another system.

if (systemRefTo.HasCyclicDependency(system))

{

    Console.WriteLine("The system {0} has a cyclic dependency on system {1}.", ((IAgCrdn)systemRefTo.GetSystem()).Name, ((IAgCrdn)system).Name);

}

Create a non-persistent point fixed in a specified reference frame given Cartesian data (using common tasks).

[C#] Copy Code

// IAgCrdnProvider provider: An instance of a central body VGT provider

// IAgFacility facility: An instance of a facility


double X, Y, Z;

facility.Position.QueryCartesian(out X, out Y, out Z);

IAgCrdnPointFixedInSystem origin = provider.Points.CommonTasks.CreateFixedInSystemCartesian(

    provider.Systems["Fixed"], X, Y, Z);

Create a non-persistent point fixed in a specified reference frame given Cartographic data (using common tasks).

[C#] Copy Code

// IAgCrdnProvider provider: An instance of a central body VGT provider

// IAgFacility facility: An instance of a facility


object lat = 0, lon = 0;

double alt = 0;

facility.Position.QueryPlanetodetic(out lat, out lon, out alt);

IAgCrdnPointFixedInSystem origin = provider.Points.CommonTasks.CreateFixedInSystemCartographic(

    provider.Systems["Fixed"], lat, lon, alt);

Create a system assembled from a point serving as its origin and a set of reference axes.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// IAgCrdnPoint OriginPoint: A point of origin.

// IAgCrdnAxes ReferenceAxes: A reference axes.


IAgCrdnSystemAssembled system = (IAgCrdnSystemAssembled)provider.Systems.Factory.Create(

    "SystemName", string.Empty, AgECrdnSystemType.eCrdnSystemTypeAssembled);

// Set the system's origin point.

system.OriginPoint.SetPoint(OriginPoint);

// Set the system's reference axes.

system.ReferenceAxes.SetAxes(ReferenceAxes);

Creates a East-North-Up system at the specified geodetic location (using common tasks).

[C#] Copy Code

// IAgCrdnProvider provider: An instance of a VGT provider

// IAgFacility facility: An instance of a facility


object lat = 0, lon = 0;

double alt = 0;

facility.Position.QueryPlanetodetic(out lat, out lon, out alt);

IAgCrdnSystemAssembled systemAssembled = provider.Systems.CommonTasks.CreateEastNorthUpCartographic(lat, lon, alt);

Creates a system assembled from an origin point and a set of reference axes (using common tasks).

[C#] Copy Code

// IAgCrdnProvider provider: An instance of a central body VGT provider

// IAgFacility facility: An instance of a facility


IAgCrdnSystemAssembled systemAssembled = provider.Systems.CommonTasks.CreateAssembled(

    ((IAgStkObject)facility).Vgt.Points["Center"], provider.Axes["Fixed"]);

Determine if the specified System type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// AgECrdnSystemType SystemType: A system type


// Check if the specified system type is supported.

if (provider.Systems.Factory.IsTypeSupported(SystemType))

{

    //Create a System with supported Type

    IAgCrdnSystem system = provider.Systems.Factory.Create("SystemName",

        string.Empty, SystemType);

}

Enumerate the existing systems.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through existing systems (coordinate reference frames).

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing system with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider


// Check if the specified system exists.

if (provider.Systems.Contains("SystemName"))

{

    provider.Systems.Remove("SystemName");

}

Check whether the reference vector has a cyclic dependency on another vector.

[C#] Copy Code

// IAgCrdnVectorRefTo vectorRefTo: Reference to a vector.

// IAgCrdnVector vector: A vector to check against reference vector.


//Check if the reference vector has a cyclic dependency on another vector.

if (vectorRefTo.HasCyclicDependency(vector))

{

    Console.WriteLine("The vector {0} has a cyclic dependency on vector {1}.", ((IAgCrdn)vectorRefTo.GetVector()).Name, ((IAgCrdn)vector).Name);

}

Check whether the vector with the specified name already exists.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// String VectorName: Name of the vector to check for.


//Check if the vector with specified name already exists.

if (provider.Vectors.Contains(VectorName))

{

    Console.WriteLine("The vector {0} already exists!", VectorName);

}

Computes the vector in the Earth's Fixed axes.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider

// IAgCrdnVector vector: A valid VGT vector object.


IAgCrdnVectorFindInAxesResult result = vector.FindInAxes(0, provider.WellKnownAxes.Earth.Fixed);

if (result.IsValid)

{

    Console.WriteLine("Vector in the Earth's Fixed axes (x,y,z) => {0},{1},{2}",

        result.Vector.X, result.Vector.Y, result.Vector.Z);

}

Create a displacement vector defined by its origin and destination points.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// IAgCrdnPoint OriginPoint: Defines the vector origin.

// IAgCrdnPoint DestinationPoint: Defines the vector destination.


//Create a displacement vector with two specified points

IAgCrdnVectorDisplacement vector = provider.Vectors.Factory.CreateDisplacementVector(

    "VectorName", OriginPoint, DestinationPoint);

Creates a vector defined as a cross product of vectors A and B.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// IAgCrdnVector VectorA: First vector.

// IAgCrdnVector VectorB: Second vector.


//Create a vector defined as cross product of vectors A and B.

IAgCrdnVectorCross vector = provider.Vectors.Factory.CreateCrossProductVector(

    "CrossVector", VectorA, VectorB);

Determine if the specified vector type is supported.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// AgECrdnVectorType vectorType: A vector type.


//Check if the specified vector type is supported.

if (provider.Vectors.Factory.IsTypeSupported(vectorType))

{

    // Create a custom vector.

    IAgCrdnVector vector = provider.Vectors.Factory.Create(

        "myVector", string.Empty, vectorType);

}

Enumerate the existing vectors.

[C#] Copy Code

// IAgCrdnProvider provider: A Vector Geometry Tool provider


// 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);

}

Iterate through the existing vectors.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.


// 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);

}

Remove an existing vector with the specified name.

[C#] Copy Code

// IAgCrdnProvider provider: An instance of VGT provider.

// String VectorName: A name of the vector to be removed.


// Check if the vector with specified name already exists.

if (provider.Vectors.Contains(VectorName))

{

    provider.Vectors.Remove(VectorName);

}

Enumerate all 2D (Map) windows and print their map identifiers.

[C#] Copy Code

// AgUiApplication application: STK Application object


foreach (IAgUiWindow window in application.Windows)

{

    object oSvc = window.GetServiceByType(AgEWindowService.eWindowService2DWindow);

    IAgUiWindowMapObject mapObject = oSvc as IAgUiWindowMapObject;

    if (mapObject != null)

    {

        Console.WriteLine("Window Title: {0}, scene ID: {1}", window.Caption, mapObject.MapID);

    }

}

Enumerate all 2D (Map) windows and print their map identifiers.

[C#] Copy Code

// AgUiApplication application: STK Application object


foreach (IAgUiWindow window in application.Windows)

{

    object oSvc = window.GetServiceByType(AgEWindowService.eWindowService2DWindow);

    IAgUiWindowMapObject mapObject = oSvc as IAgUiWindowMapObject;

    if (mapObject != null)

    {

        Console.WriteLine("Window Title: {0}, scene ID: {1}", window.Caption, mapObject.MapID);

    }

}

Enumerate all 3D (Globe) windows and print their scene identifiers.

[C#] Copy Code

// AgUiApplication application: STK Application object


foreach (IAgUiWindow window in application.Windows)

{

    object oSvc = window.GetServiceByType(AgEWindowService.eWindowService3DWindow);

    IAgUiWindowGlobeObject globeObject = oSvc as IAgUiWindowGlobeObject;

    if (globeObject != null)

    {

        Console.WriteLine("Window Title: {0}, scene ID: {1}", window.Caption, globeObject.SceneID);

    }

}

Enumerate all 3D (Globe) windows and print their scene identifiers.

[C#] Copy Code

// AgUiApplication application: STK Application object


foreach (IAgUiWindow window in application.Windows)

{

    object oSvc = window.GetServiceByType(AgEWindowService.eWindowService3DWindow);

    IAgUiWindowGlobeObject globeObject = oSvc as IAgUiWindowGlobeObject;

    if (globeObject != null)

    {

        Console.WriteLine("Window Title: {0}, scene ID: {1}", window.Caption, globeObject.SceneID);

    }

}

Computes the distance between two locations.

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgStkCentralBodyEllipsoid centralBodyEllipsoid = root.CentralBodies["Earth"].Ellipsoid;


// Compute the distance between Philadelphia and London.

// The code snippet assumes the latitude and longitude unit preference is set to degrees.

double distance = centralBodyEllipsoid.ComputeSurfaceDistance(40.0068, -75.1347, 51.4879, -0.1780);

Console.WriteLine("The distance between Philadelphia and London is: {0}", distance);

Create 2525b symbol

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// String filePath: Saved image file path


// Generate a 2525b symbol

IAgStdMil2525bSymbols symbol = root.StdMil2525bSymbols;


// Configure symbol properties

symbol.SymbolImageSize = 128;

symbol.FillEnabled = true;


// CreateSymbol

symbol.CreateSymbol("sjgpewrh--mtusg", filePath);

Gets the altitude of the terrain at a single location and in batches.

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// Double latitude: Terrain Latitude Position

// Double longitude: Terrain Longitude Position

// String terrainFile: Path of Terrain file


IAgScenario scneario = (IAgScenario)root.CurrentScenario;


// If you haven't done so, add the terrain to your scenario (for example .PDTT)

IAgCentralBodyTerrainCollectionElement earthTerrain = scneario.Terrain["Earth"];

earthTerrain.TerrainCollection.Add(terrainFile, AgETerrainFileType.ePDTTTerrainFile);


// Get single altitude

double altitude = earthTerrain.GetAltitude(latitude, longitude, AgEAltRefType.eMSL);


// Get points in batches.

Array specifiedPositions = new object[,]

{

    { 40.0386, -75.5966 },

    { 28.5383, -81.3792 },

    { 37.7749, -122.4194 }

};


Array altitudes = earthTerrain.GetAltitudeBatch(ref specifiedPositions, AgEAltRefType.eWGS84);


// GetAltitudeBatch returns a one-dimensional array of altitude values in the distance unit perference.

int numPoints = altitudes.GetLength(0);

for (int i = 0; i < numPoints; ++i)

{

    Console.WriteLine("Latitude={0}, Longitude={1}, Altitude={2}", specifiedPositions.GetValue(i, 0), specifiedPositions.GetValue(i, 1), altitudes.GetValue(i));

}

Gets the altitude profile of the terrain.

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root

// String terrainFile: Path of Terrain file


IAgScenario scneario = (IAgScenario)root.CurrentScenario;


// If you haven't done so, add the terrain to your scenario (for example .PDTT)

IAgCentralBodyTerrainCollectionElement earthTerrain = scneario.Terrain["Earth"];

IAgTerrain terrain = earthTerrain.TerrainCollection.Add(terrainFile, AgETerrainFileType.ePDTTTerrainFile);


// Get diagonal altitude profile using the max resolution of the terrain file.

Array terrainProfile = earthTerrain.GetAltitudesBetweenPointsAtResolution(terrain.SWLatitude, terrain.SWLongitude, terrain.NELatitude, terrain.NELongitude, terrain.Resolution, AgEDistanceOnSphere.eDistanceOnSphereGreatCircle, AgEAltRefType.eMSL);


// GetAltitudeProfile returns a two dimensional array of lat lon alt values.

int numPoints = terrainProfile.GetLength(0);

for (int i = 0; i < numPoints; ++i)

{

    Console.WriteLine("Latitude={0}, Longitude={1}, Altitude={2}", terrainProfile.GetValue(i, 0), terrainProfile.GetValue(i, 1), terrainProfile.GetValue(i, 2));

}

Load a VDF

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model Root

// String vdfPath: The full file path of the VDF

// String vdfPassword: The password to open the VDF


// Pass an empty string if there is no password to the VDF.

root.LoadVDF(vdfPath, vdfPassword);

Sets the scenario analysis time to the empheris time of another object.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root

// IAgScenario scenario: Scenario object


IAgSatellite satellite = stkRoot.GetObjectFromPath("/Satellite/GeoEye") as IAgSatellite;


IAgCrdnProvider vgtProvider = stkRoot.VgtRoot.GetProvider("/Satellite/GeoEye");

IAgVePropagatorTwoBody twoBody = satellite.Propagator as IAgVePropagatorTwoBody;

IAgCrdnEventSmartEpoch startEpoch = twoBody.EphemerisInterval.GetStartEpoch();

IAgCrdnEventSmartEpoch stopEpoch = twoBody.EphemerisInterval.GetStopEpoch();


scenario.AnalysisInterval.SetStartAndStopEpochs(startEpoch, stopEpoch);

Sets the scenario analysis time to today and the duration to one day.

[C#] Copy Code

// IAgStkObjectRoot stkRoot: STK Object Model root

// IAgScenario scenario: Scenario object


scenario.AnalysisInterval.SetStartTimeAndDuration("Today", "+1 Day");

Execute Connect command

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgExecCmdResult result = root.ExecuteCommand("New / */Satellite JeffSAT");

Execute multiple Connect commands

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


Array connectCommands = new object[]

    {

        "New / */Satellite MySatellite",

        "Graphics */Satellite/MySatellite SetColor red"

    };


// ExecuteMultipleCommands expect a one dimensional array of Connect commands

IAgExecMultiCmdResult result = root.ExecuteMultipleCommands(ref connectCommands, AgEExecMultiCmdResultAction.eExceptionOnError);

Extract data from a multiple Connect result

[C#] Copy Code

// IAgExecMultiCmdResult result: Connect mutiple exection result


for (int i = 0; i < result.Count; i++)

{

    if (result[i].IsSucceeded)

    {

        for (int j = 0; j < result[i].Count; j++)

        {

            Console.WriteLine(result[j]);

        }

    }

}

Extract data from Connect result

[C#] Copy Code

// IAgExecCmdResult result: Connect exection result


if (result.IsSucceeded)

{

    for (int i=0; i<result.Count; i++)

    {

        Console.WriteLine(result[i]);

    }

}

Convert a position to another representation

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgConversionUtility converter = root.ConversionUtility;


// ConvertPositionArray expects a two dimensional array of positions

Array cartesianPositions = new object[,]

    {

        { 1216.47, -4736.12, 4081.39 },

        { 1000, -2000, 2000 }

    };


// Convert cartesian dates to cylindrical

// ConvertPositionArray returns a two dimensional array of cartesian dates

Array cylindricalPositions = converter.ConvertPositionArray(AgEPositionType.eCartesian, ref cartesianPositions, AgEPositionType.eCylindrical);


// Print results

for (int i = 0; i < cylindricalPositions.GetLength(0); i++)

{

    Console.WriteLine("X: {0}, Y: {1}, Z: {2}",

        cylindricalPositions.GetValue(i, 0),

        cylindricalPositions.GetValue(i, 1),

        cylindricalPositions.GetValue(i, 2));

}

Convert an orbit state to another representation or coordinate system X

[C#] Copy Code

// IAgOrbitState orbit: Orbit State


IAgOrbitStateClassical newOrbit = orbit.ConvertTo(AgEOrbitStateType.eOrbitStateClassical) as IAgOrbitStateClassical;

Extends orbit state to another representation or coordinate system X

[C#] Copy Code

// IAgOrbitState orbitState: Orbit State


// orbitState can be extended to one of the other representations.

// Here it is extended to Classical representation.

IAgOrbitStateClassical newOrbitState = orbitState.ConvertTo(AgEOrbitStateType.eOrbitStateClassical) as IAgOrbitStateClassical;


// Set the new orbit state parameters

newOrbitState.AssignClassical(AgECoordinateSystem.eCoordinateSystemICRF, 12000000, 0, 1.8, 0, -1.8, 0);

Query direction as another representation

[C#] Copy Code

// IAgDirection direction: Direction


// Method 1

object b = null, c = null;

direction.QueryEuler(AgEEulerDirectionSequence.e12, out b, out c);

Console.WriteLine("B = {0}, C = {1}", b, c);

// Method 2

// The Query functions returns a one dimension array

// The number of column rows depends on the representation

Array euler = direction.QueryEulerArray(AgEEulerDirectionSequence.e12);

Console.WriteLine("B = {0}, C = {1}", euler.GetValue(0), euler.GetValue(1));

Delay graphics updates while manipulating properties of an object

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Root


IAgSatellite satellite = root.CurrentScenario.Children["Satellite1"] as IAgSatellite;

IAgVODataDisplayElement voElt = satellite.VO.DataDisplay[0];


root.BeginUpdate(); // Suspend updates


// Put modifications here

voElt.IsVisible = true;

voElt.UseBackground = true;

voElt.BgColor = Color.Green;

voElt.UseBackground = false;


root.EndUpdate(); // Resume updates now

Calculate date addition (with IAgDate)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create a date representing now

IAgDate nowDate = root.ConversionUtility.NewDate("DD/MM/YYYY", DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss.fff"));


// Dates can be modified using Add 52 days

IAgDate newDate = nowDate.Add("day", 52.0);


// Differences between dates are calculated from Span function

IAgQuantity span = newDate.Span(nowDate);


// IAgDate also provides formatting functionalities

span.ConvertToUnit("min");

Console.WriteLine("Date(now) in UTCG is: {0}", nowDate.Format("UTCG"));

Console.WriteLine("Date(52 days from now) in UTCG is: {0}", newDate.Format("UTCG"));

Console.WriteLine("The difference between now and 52 days to come is {0} minutes!", span.Value);

Calculate date subtraction (with IAgDate)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create a date representing now

IAgDate nowDate = root.ConversionUtility.NewDate("DD/MM/YYYY", DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss.fff"));


// Dates can be modified using Subtract 52 days

IAgDate newDate = nowDate.Subtract("day", 52.0);


// Differences between dates are calculated from Span function

IAgQuantity span = newDate.Span(nowDate);


// IAgDate also provides formatting functionalities

span.ConvertToUnit("min");

Console.WriteLine("Date(now) in UTCG is: {0}", nowDate.Format("UTCG"));

Console.WriteLine("Date(52 days before now) in UTCG is: {0}", newDate.Format("UTCG"));

Console.WriteLine("The difference between now and 52 days ago is {0} minutes!", span.Value);

Calculate quantity addition (with IAgQuantity)

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Create a quantity representing a 3.1 mile/ 5 km fun run race

IAgQuantity  race3mi = root.ConversionUtility.NewQuantity("Distance", "mi", 3.1);

IAgQuantity  race5km = root.ConversionUtility.NewQuantity("Distance", "km", 5);


// Add the two 3.1 mile/ 5 km runs

IAgQuantity race10km = race5km.Add(race3mi);

Console.Write("The {0} {1} race is also called a ", race10km.Value, race10km.Unit);


// Convert 10k run to 6.2 mile run internally within the quantity

race10km.ConvertToUnit("mi");

Console.WriteLine("{0} {1} race", race10km.Value, race10km.Unit);

Convert a date format to another format

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgConversionUtility converter = root.ConversionUtility;


// Individually

string epsec = converter.ConvertDate("UTCG", "Epsec", "1 Jan 2012 12:00:00.000");

string utcg = converter.ConvertDate("EpSec", "UTCG", "230126401.000");

Convert a quantity unit to another unit

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgConversionUtility converter = root.ConversionUtility;


// Old value in miles, new value in km

double newValue = converter.ConvertQuantity("DistanceUnit", "mi", "km", 1.0);

Convert mulitple quantities of the same unit to another unit

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgConversionUtility converter = root.ConversionUtility;


// ConvertQuantityArray expects a one dimensional array of values to be converted

// An array of km/sec units

Array kmsecUnits = new object[]

                   {

                       100, 23

                   };


// Convert to mi/sec units

// ConvertQuantityArray returns a one dimensional array of converted values

Array misecUnits = converter.ConvertQuantityArray("Rate", "km/sec", "mi/sec", ref kmsecUnits);

Convert multiple dates of the same format to another format

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


IAgConversionUtility converter = root.ConversionUtility;


// In batches

// ConvertDateArray expects a one dimensional array of dates

// An array of UTCG dates

Array tempDates = new object[]

                  {

                      "1 Jan 2012 12:00:00.000", "1 Jan 2012 14:00:00.000"

                  };


// Convert UTCG array to EpSec

// ConvertDateArray returns a one dimensional array of converted dates

Array converted = converter.ConvertDateArray("UTCG", "Epsec", ref tempDates);


// Print results

for (int i = 0; i < converted.Length; i++)

{

    Console.WriteLine("Date: {0}", converted.GetValue(i));

}

Get a current unit preference

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// DistanceUnit

string dimensionName = "Distance";

string unitAbbreviation = root.UnitPreferences.GetCurrentUnitAbbrv(dimensionName);

Isolate Unit Preferences when using multiple IAgStkObjectRoot objects

[C#] Copy Code


// First root configured to use km

IAgStkObjectRoot root1 = new AgStkObjectRootClass();

root1.UnitPreferences.SetCurrentUnit("Distance", "km");


// Second root configured to use miles

IAgStkObjectRoot root2 = new AgStkObjectRootClass();

root2.Isolate();

root2.UnitPreferences.SetCurrentUnit("Distance", "mi");


// Create new scenario and ship object

// Close current scenario

if (root1.CurrentScenario != null)

{

    root1.CloseScenario();

}

root1.NewScenario("Test");

root1.CurrentScenario.Children.New(AgESTKObjectType.eShip, "Ship1");


// Obtain references to the ship object from each root

IAgShip shipFromRoot1 = root1.GetObjectFromPath("Ship/Ship1") as IAgShip;

IAgShip shipFromRoot2 = root2.GetObjectFromPath("Ship/Ship1") as IAgShip;


shipFromRoot1.SetRouteType(AgEVePropagatorType.ePropagatorGreatArc);


IAgVePropagatorGreatArc greatArcFromRoot1 = shipFromRoot1.Route as IAgVePropagatorGreatArc;

IAgVePropagatorGreatArc greatArcFromRoot2 = shipFromRoot2.Route as IAgVePropagatorGreatArc;


IAgVeWaypointsElement waypointsFromRoot1 = greatArcFromRoot1.Waypoints.Add();


waypointsFromRoot1.Altitude = 1; // 1 km


IAgVeWaypointsElement waypointsFromRoot2 = greatArcFromRoot2.Waypoints.Add();


waypointsFromRoot2.Altitude = 1; // 1 mile


greatArcFromRoot1.Propagate();


int i = 1;

foreach (IAgVeWaypointsElement wpt in greatArcFromRoot1.Waypoints)

{

    Console.WriteLine("Point #{0} Altitude {1} {2}", i, wpt.Altitude, root1.UnitPreferences.GetCurrentUnitAbbrv("Distance"));

    ++i;

}

Console.WriteLine();


//Sample Output

//Point #1 Altitude 1 km

//Point #2 Altitude 1.609344 km


i = 1;

foreach (IAgVeWaypointsElement wpt in greatArcFromRoot2.Waypoints)

{

    Console.WriteLine("Point #{0} Altitude {1} {2}", i, wpt.Altitude, root2.UnitPreferences.GetCurrentUnitAbbrv("Distance"));

    ++i;

}


//Sample Output

//Point #1 Altitude 0.621371192237334 mi

//Point #2 Altitude 1 mi


root1.CloseScenario();

Reset all current unit preferences

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// Reset Units

root.UnitPreferences.ResetUnits();

Set a current unit preference

[C#] Copy Code

// IAgStkObjectRoot root: STK Object Model root


// DistanceUnit

root.UnitPreferences.SetCurrentUnit("Distance", "m");

C# Code Snippets

Introduction

How do I ...

Initialization

STK Objects

Area Target

Chain

Common

Access

Data Providers

Graphics

2D

3D

Object Coverage

Communications

Link Budget

Constellation

Coverage Definition

Advanced

Graphics

Facility

Figure of Merit

MTO

Analysis

Graphics

3D

Place

Planet

Graphics

Radar

Probability of Detection

Scenario

Graphics

Object Management

Scenario Management

Sensor

Graphics

3D

Star

Target

Vehicles

Aircraft

Common

Attitude

Graphics

3D

Propagators

Astrogator

Ballistic

GPS

Great Arc

HPOP

J2 Perturbation

J4 Perturbation

LOP

Realtime

SGP4

Simple Ascent

SPICE

Ground Vehicle

Launch Vehicle

Missile

Satellite

Ship

STK Plugins

Attributes

Graphics

Bounding Sphere

Box Triangulator

Camera

Convolution Filter

Display Condition

DisplayConditions

Ellipsoid Triangulator

Extruded Polyline Triangulator

GlobeOverlays

Imaging

Jpeg2000 Writer

Model Primitive

Overlay