/// <summary>
/// Create a fan to visualize an azimuth-elevation mask.
/// </summary>
private void CreateAzimuthElevationMask()
{
// load terrain data for Mount St. Helens.
string dataPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, AppDomain.CurrentDomain.RelativeSearchPath ?? "", "Data");
var terrain = new AGIProcessedDataTerrain(Path.Combine(dataPath, @"Terrain\StHelens.pdtt"));
// Calculate the surface position at the center of the terrain
double longitude = (terrain.BoundingExtent.WestLongitude + terrain.BoundingExtent.EastLongitude) / 2.0;
double latitude = (terrain.BoundingExtent.NorthLatitude + terrain.BoundingExtent.SouthLatitude) / 2.0;
Cartographic observerPosition = new Cartographic(longitude, latitude, terrain.GetHeight(longitude, latitude));
// Sample using 360 azimuth rays at 0.000275 degrees
const int numberOfAzimuthSteps = 360;
double stepSize = Trig.DegreesToRadians(0.000275);
const double maxSearchAngle = 0.025;
// Compute the mask.
var mask = TerrainAzimuthElevationMask.Compute(terrain, observerPosition, numberOfAzimuthSteps, stepSize, maxSearchAngle);
var locationPoint = new PointCartographic(m_earth, observerPosition);
m_maskPlatform = new Platform
{
Name = "Azimuth Elevation Mask",
LocationPoint = locationPoint,
OrientationAxes = new AxesNorthEastDown(m_earth, locationPoint),
};
// Set the identifier for the mask in the CZML document.
m_maskPlatform.Extensions.Add(new IdentifierExtension("Mask"));
// Attach the computed mask.
m_maskPlatform.Extensions.Add(new AzimuthElevationMaskExtension(mask));
// Define the graphics of the mask.
m_maskPlatform.Extensions.Add(new AzimuthElevationMaskGraphicsExtension(new AzimuthElevationMaskGraphics
{
ProjectionRange = 5000.0,
Material = new StripeMaterialGraphics
{
EvenColor = Color.Blue,
OddColor = Color.White,
Repeat = 16.0,
},
Projection = AzimuthElevationMaskGraphicsProjection.ProjectToRange,
NumberOfRings = 8,
Outline = true,
OutlineColor = Color.Black,
OutlineWidth = 2.0,
}));
}
public Main()
{
InitializeComponent();
var earth = CentralBodiesFacet.GetFromContext().Earth;
// Load the GPS satellites from the almanac, including transmitters for specific block types,
// using the data from the GPSData.txt file.
m_gpsConstellation = GetGpsCommunicationsConstellation();
// create the receiver using a standard setup
m_receiver = new GpsReceiver
{
NumberOfChannels = 12,
ReceiverSolutionType = GpsReceiverSolutionType.AllInView, NavigationSatellites = m_gpsConstellation
};
m_receiver.ReceiverConstraints.Add(new ElevationAngleConstraint(Trig.DegreesToRadians(5.0)));
m_location = new PointCartographic(earth, new Cartographic(Trig.DegreesToRadians(-107.494000), Trig.DegreesToRadians(30.228800), 0));
m_orientation = new AxesEastNorthUp(earth, m_location);
}
/// <summary>
/// Create a facility at the location of AGI headquarters.
/// The facility will be visually represented by a labeled glTF model.
/// </summary>
private void CreateFacility()
{
// Define the location of the facility using cartographic coordinates.
var location = new Cartographic(Trig.DegreesToRadians(-75.596766667), Trig.DegreesToRadians(40.0388333333), 0.0);
var locationPoint = new PointCartographic(m_earth, location);
m_facility = new Platform
{
Name = "AGI HQ",
LocationPoint = locationPoint,
// Orient the facility using East-North-Up (ENU) axes.
OrientationAxes = new AxesEastNorthUp(m_earth, locationPoint),
};
// Set the identifier for the facility in the CZML document.
m_facility.Extensions.Add(new IdentifierExtension("AGI"));
// Configure a glTF model for the facility.
m_facility.Extensions.Add(new ModelGraphicsExtension(new ModelGraphics
{
// Link to a binary glTF file.
Model = new CesiumResource(GetModelUri("facility.glb"), CesiumResourceBehavior.LinkTo),
RunAnimations = false,
HeightReference = CesiumHeightReference.ClampToGround,
}));
// Configure label for AGI HQ.
m_facility.Extensions.Add(new LabelGraphicsExtension(new LabelGraphics
{
Text = m_facility.Name,
FillColor = Color.White,
// Only show label when camera is far enough from the satellite,
// to avoid visually clashing with the model.
DistanceDisplayCondition = new Bounds(1000.0, double.MaxValue),
HeightReference = CesiumHeightReference.ClampToGround,
}));
}
private void OnLoad(object sender, EventArgs e)
{
// Create overlay toolbar and panels
m_overlayToolbar = new OverlayToolbar(m_insight3D);
m_overlayToolbar.Overlay.Origin = ScreenOverlayOrigin.BottomCenter;
// Add additional toolbar buttons
// Number of Satellites Button
m_overlayToolbar.AddButton(GetDataFilePath("Textures/OverlayToolbar/manysatellites.png"),
GetDataFilePath("Textures/OverlayToolbar/fewsatellites.png"),
ToggleNumberOfSatellites);
// Show/Hide Access Button
m_overlayToolbar.AddButton(GetDataFilePath("Textures/OverlayToolbar/noshowaccess.png"),
GetDataFilePath("Textures/OverlayToolbar/showaccess.png"),
ToggleComputeAccess);
// Initialize the text panel
m_textPanel = new TextureScreenOverlay(0, 0, 80, 35)
{
Origin = ScreenOverlayOrigin.TopRight,
BorderSize = 2,
BorderColor = Color.Transparent,
BorderTranslucency = 0.6f,
Color = Color.Transparent,
Translucency = 0.4f
};
SceneManager.ScreenOverlays.Add(m_textPanel);
// Show label for the moon
Scene scene = m_insight3D.Scene;
scene.CentralBodies[CentralBodiesFacet.GetFromContext().Moon].ShowLabel = true;
// Create a marker primitive for the facility at Bells Beach Australia
EarthCentralBody earth = CentralBodiesFacet.GetFromContext().Earth;
Cartographic facilityPosition = new Cartographic(Trig.DegreesToRadians(144.2829), Trig.DegreesToRadians(-38.3697), 0.0);
Texture2D facilityTexture = SceneManager.Textures.FromUri(GetDataFilePath(@"Markers\Facility.png"));
MarkerBatchPrimitive marker = new MarkerBatchPrimitive(SetHint.Infrequent)
{
Texture = facilityTexture
};
marker.Set(new[] { earth.Shape.CartographicToCartesian(facilityPosition) });
SceneManager.Primitives.Add(marker);
PointCartographic point = new PointCartographic(earth, facilityPosition);
Axes topographic = new AxesNorthEastDown(earth, point);
ReferenceFrame facilityTopo = new ReferenceFrame(point, topographic);
m_fixedToFacilityTopoEvaluator = GeometryTransformer.GetReferenceFrameTransformation(earth.FixedFrame, facilityTopo);
Axes temeAxes = earth.TrueEquatorMeanEquinoxFrame.Axes;
m_temeToFixedEvaluator = GeometryTransformer.GetAxesTransformation(temeAxes, earth.FixedFrame.Axes);
m_showAccess = true;
m_satellites = new Satellites();
CreateSatellites("stkSatDb");
// This Render() is needed so that the stars will show.
scene.Render();
}
/// <summary>
/// Method to calculate all the data required for the graphs.
/// </summary>
private void OnAddReceiverClick(object sender, EventArgs e)
{
#region CreateAndConfigureReceiver
// Let's create the GPSReceiver. The receiver stores many properties and has a defined location. This location
// is the point of reference for visibility calculations.
receiver = new GpsReceiver();
// add receiver to the tree
TreeNode newNode = new TreeNode(Localization.Receiver);
rootNode.Nodes.Add(newNode);
// Easy reference to Earth Central body used to initialize the ElevationAngleAccessConstraint and
// to calculate the Az/El/Range Data.
EarthCentralBody earth = CentralBodiesFacet.GetFromContext().Earth;
// set the receiver properties based on user selections
// The receiver has a receiver FrontEnd that contains the visibility and tracking constraints
// Be sure to convert your angles to Radians!
double minimumAngle = Trig.DegreesToRadians(Double.Parse(MaskAngle.Text));
receiver.ReceiverConstraints.Clear();
receiver.ReceiverConstraints.Add(new ElevationAngleConstraint(earth, minimumAngle));
receiver.NumberOfChannels = (int)NumberOfChannels.Value;
receiver.NoiseModel = new ConstantGpsReceiverNoiseModel(0.8);
// The receiver's methods of reducing the number of visible satellites to the limit imposed by the number of channels
if (BestNSolType.Checked)
{
receiver.ReceiverSolutionType = GpsReceiverSolutionType.BestN;
}
else
{
receiver.ReceiverSolutionType = GpsReceiverSolutionType.AllInView;
}
// create a new location for the receiver by using the Cartographic type from AGI.Foundation.Coordinates
// again, remember to convert from degrees to Radians! (except the height of course)
Cartographic position = new Cartographic(Trig.DegreesToRadians(double.Parse(Longitude.Text)),
Trig.DegreesToRadians(double.Parse(Latitude.Text)),
double.Parse(ReceiverHeight.Text));
// Now create an antenna for the GPS receiver. We specify the location of the antenna by assigning a
// PointCartographic instance to the LocationPoint property. We specify that the antenna should be oriented
// according to the typically-used East-North-Up axes by assigning an instance of AxesEastNorthUp to
// the OrientationAxes property. While the orientation of the antenna won't affect which satellites are visible
// or tracked in this case, it will affect the DOP values. For example, the EDOP value can be found in
// DilutionOfPrecision.X, but only if we've configured the antenna to use East-North-Up axes.
PointCartographic antennaLocationPoint = new PointCartographic(earth, position);
Platform antenna = new Platform
{
LocationPoint = antennaLocationPoint,
OrientationAxes = new AxesEastNorthUp(earth, antennaLocationPoint)
};
receiver.Antenna = antenna;
#endregion
// update the tree to reflect the correct receiver info
newNode.Nodes.Add(new TreeNode(string.Format(Localization.FixedMaskAngle + "= {0:0.00} " + Localization.degrees, MaskAngle.Text)));
newNode.Nodes.Add(new TreeNode(string.Format(Localization.NumberOfChannels + "= {0}", NumberOfChannels.Value)));
newNode.Nodes.Add(new TreeNode(string.Format(Localization.SolutionType + "= {0}", receiver.ReceiverSolutionType == GpsReceiverSolutionType.AllInView ? Localization.AllInView : Localization.BestN)));
newNode.Nodes.Add(new TreeNode(string.Format(Localization.Latitude + "= {0:0.000000} " + Localization.degrees, Latitude.Text)));
newNode.Nodes.Add(new TreeNode(string.Format(Localization.Longitude + "= {0:0.000000} " + Localization.degrees, Longitude.Text)));
newNode.Nodes.Add(new TreeNode(string.Format(Localization.Height + "= {0:0.000} " + Localization.meters, ReceiverHeight.Text)));
rootNode.Expand();
newNode.Expand();
#region CalculateDataForGraphs
// Now, we'll open the almanac
SemAlmanac almanac;
using (Stream stream = openAlmanacDialog.OpenFile())
using (StreamReader reader = new StreamReader(stream))
{
// Read the SEM almanac from an almanac stream reader.
almanac = SemAlmanac.ReadFrom(reader, 1);
}
// Now create a PlatformCollection to hold GpsSatellite object instances. The SemAlmanac method CreateSatellitesFromRecords returns
// just such a collection. We'll use this set of satellites as the set from which we'll try and track. There is a
// GpsSatellite object for each satellite specified in the almanac.
PlatformCollection gpsSatellites = almanac.CreateSatelliteCollection();
// We provide the receiver with the complete set of gpsSatellites to consider for visibility calculations.
// This is usually all SVs defined in the almanac - however you may want to remove SVs that aren't healthy. This can
// be done by creating the gpsSatellites collection above using another version of the CreateSatellitesFromRecords method that
// takes a SatelliteOutageFileReader.
receiver.NavigationSatellites = gpsSatellites;
// Optimization opportunity: Add the following code in a thread. This will help for long duration analyses.
// Now that we have the receiver and location setup, we need to evaluate all the pertinent data.
// using a SatelliteTrackingEvaluator, we can track satellites and using a DOP Evaluator,
// we can calculate DOP at a specified time.
// The receiver's GetSatelliteTrackingEvaluator method will provide a SatelliteTrackingEvaluator for you.
// Similarly, the GetDilutionOfPrecisionEvaluator provides the DOP evaluator.
// We create all evaluators in the same EvaluatorGroup for the best performance.
EvaluatorGroup group = new EvaluatorGroup();
Evaluator <int[]> satTrackingEvaluator = receiver.GetSatelliteTrackingIndexEvaluator(group);
Evaluator <DilutionOfPrecision> dopEvaluator = receiver.GetDilutionOfPrecisionEvaluator(group);
// We also need to create an evaluator to compute Azimuth/Elevation for each of the SVs
MotionEvaluator <AzimuthElevationRange>[] aerEvaluators = new MotionEvaluator <AzimuthElevationRange> [gpsSatellites.Count];
for (int i = 0; i < gpsSatellites.Count; ++i)
{
Platform satellite = receiver.NavigationSatellites[i];
VectorTrueDisplacement vector = new VectorTrueDisplacement(antenna.LocationPoint, satellite.LocationPoint);
aerEvaluators[i] = earth.GetAzimuthElevationRangeEvaluator(vector, group);
}
// First we'll initialize the data structures used to plot the data
for (int i = 0; i < DOPData.Length; i++)
{
// PointPairList is defined in the ZedGraph reference
DOPData[i] = new PointPairList();
}
// We need to know which time standard to use here. If the user has specified that GPS time is to be used
// we need to create the JulianDates with the GlobalPositioningSystemTime standard.
if (GPSTimeRadio.Checked)
{
startjd = new JulianDate(StartTime.Value, TimeStandard.GlobalPositioningSystemTime);
stopjd = new JulianDate(StopTime.Value, TimeStandard.GlobalPositioningSystemTime);
}
else
{
// otherwise, the default time standard is UTC
startjd = new JulianDate(StartTime.Value);
stopjd = new JulianDate(StopTime.Value);
}
// Now we''ll create the variables we'll need for iterating through time.
// The propagator requires a Duration type be used to specify the timestep.
Duration dur = stopjd - startjd;
double timestep = Double.Parse(TimeStep.Text);
// Initialize the progressbar with appropriate values
progressBar1.Maximum = (int)dur.TotalSeconds;
progressBar1.Step = (int)timestep;
// now we'll iterate through time by adding seconds to the start time JulianDate
// creating a new JulianDate 'evaluateTime' each time step.
for (double t = 0; t <= dur.TotalSeconds; t += timestep)
{
JulianDate evaluateTime = startjd.AddSeconds(t);
// The string 'trackedSVs' is the start of a string we'll continue to build through this time
// iteration. It will contain the info we'll need to put in the DOP graph tooltips for the different
// DOP series (VDOP, HDOP, etc.)
String trackedSVs = Localization.Tracked + ": ";
// The evaluator method GetTrackedSatellites will take the current time and the initial list of satellites and
// determine which satellites can be tracked based on the receiver constraints setup earlier. This method
// returns a PlatformCollection object as well (though we'll cast each member of the Collection to a GPSSatellite type)
int[] trackedSatellites = satTrackingEvaluator.Evaluate(evaluateTime);
foreach (int satelliteIndex in trackedSatellites)
{
Platform satellite = receiver.NavigationSatellites[satelliteIndex];
// Now we have access to a Platform object representing a GPS satellite and calculate the azimuth and elevation
// of each. Note that we're just calculating the azimuth and elevation, but could just as easily get the
// range as well.
AzimuthElevationRange aer = aerEvaluators[satelliteIndex].Evaluate(evaluateTime);
// Get the GpsSatelliteExtension attached to the platform. The extension extends a
// platform with GPS-specific information. In this case, we need the
// satellites PRN.
GpsSatelliteExtension extension = satellite.Extensions.GetByType <GpsSatelliteExtension>();
// Create two separate PointPairLists to hold the data stored by Time and Azimuth
PointPairList thisTimePointList, thisAzPointList;
// Before we can arbitrarily create new PointPair Lists, we have to see if the Data Storage structures already contain a list
// for this PRN.
// The variables AzElData_TimeBased and AzElData_AzimuthBased are dictionaries that hold the PointPairLists using the PRN
// as a key. We use this structure to store a large amount of data for every satellite in a single, easy to access, variable.
// if the satellite we're currently looking at already has a list defined in the dictionary, we'll use that one, otherwise
// we'll create a new list
if (AzElData_TimeBased.ContainsKey(extension.PseudoRandomNumber))
{
thisTimePointList = AzElData_TimeBased[extension.PseudoRandomNumber];
AzElData_TimeBased.Remove(extension.PseudoRandomNumber);
}
else
{
thisTimePointList = new PointPairList();
}
if (AzElData_AzimuthBased.ContainsKey(extension.PseudoRandomNumber))
{
thisAzPointList = AzElData_AzimuthBased[extension.PseudoRandomNumber];
AzElData_AzimuthBased.Remove(extension.PseudoRandomNumber);
}
else
{
thisAzPointList = new PointPairList();
}
// Now to get the actual Azimuth and elevation data
// Converting your Radians to degrees here makes the data appear in a more readable format. We also constrain the azimuth
// to be within the interval [0, 2*pi]
double azimuth = Trig.RadiansToDegrees(Trig.ZeroToTwoPi(aer.Azimuth));
double elevation = Trig.RadiansToDegrees(aer.Elevation);
#endregion
// now create the point for the Azimuth based data
PointPair thisAzPoint = new PointPair(azimuth, elevation);
// and add the tooltip (ZedGraph uses the Tag property on a PointPair for the tooltip on that datapoint )
thisAzPoint.Tag = String.Format("PRN {0}, {1}, " + Localization.Az + ": {2:0.000}, " + Localization.El + ": {3:0.000}", extension.PseudoRandomNumber, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), azimuth, elevation);
// and finally add this point to the list
thisAzPointList.Add(thisAzPoint);
// now we'll do the same for the time-based data, instead of adding the Az and El, we'll add the time and El.
// Create a new XDate object to store the time for this point
double txd = (double)new XDate(evaluateTime.ToDateTime());
// add the time and elevation data to this point
PointPair thisTimePoint = new PointPair(txd, Trig.RadiansToDegrees(aer.Elevation));
// Create the tooltip tag
thisTimePoint.Tag = String.Format("PRN {0}, {1}, " + Localization.Az + ": {2:0.000}, " + Localization.El + ": {3:0.000}", extension.PseudoRandomNumber, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), azimuth, elevation);
// finally add this point to the list
thisTimePointList.Add(thisTimePoint);
//Now that this data is all calculated, we'll add the point lists to the correct data structures for the GpsSatellite we're working with
AzElData_TimeBased.Add(extension.PseudoRandomNumber, thisTimePointList);
AzElData_AzimuthBased.Add(extension.PseudoRandomNumber, thisAzPointList);
// now update the 'trackedSVs' string to be used for the DOP data tooltip
// wee need to do this inside the GpsSatellite loop because we need to get the entire list of tracked SVs for this time step.
// we won't use this string until we're out of the loop however.
trackedSVs += extension.PseudoRandomNumber.ToString() + ", ";
}
// now we're out of the GpsSatellite loop, we'll do some string manipulation to get the tooltip for the DOP data.
// (gets rid of the last inserted comma)
string svs = trackedSVs.Substring(0, trackedSVs.LastIndexOf(' ') - 1);
try
{
// Now we use the evaluator to calculate the DilutionOfPrecision for us for this timestep
DilutionOfPrecision dop = dopEvaluator.Evaluate(evaluateTime);
// if the dop object throws an exception, there aren't enough tracked satellites to form a navigation solution (typically < 4 tracked)
// in that case we leave the data for this time unfilled. The graph will then have empty spots for this time.
// Here we create a new PointPair and a new XDate to add to the X-Axis
PointPair pp;
double txd = (double)new XDate(evaluateTime.ToDateTime());
// add the East DOP value and the time to the PointPair and set the tooltip tag property for this series.
pp = new PointPair(txd, dop.X);
pp.Tag = String.Format("{0}\n{1} " + Localization.EDOP + ": {2:0.000}", svs, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), dop.X);
// add the point to the 0th element of the DOPData structure
DOPData[0].Add(pp);
// repeat for North DOP
pp = new PointPair(txd, dop.Y);
pp.Tag = String.Format("{0}\n{1} " + Localization.NDOP + ": {2:0.000}", svs, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), dop.Y);
DOPData[1].Add(pp);
// repeat for the Vertical DOP
pp = new PointPair(txd, dop.Z);
pp.Tag = String.Format("{0}\n{1} " + Localization.VDOP + ": {2:0.000}", svs, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), dop.Z);
DOPData[2].Add(pp);
// repeat for the Horizontal DOP
pp = new PointPair(txd, dop.XY);
pp.Tag = String.Format("{0}\n{1} " + Localization.HDOP + ": {2:0.000}", svs, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), dop.XY);
DOPData[3].Add(pp);
// repeat for the Position DOP
pp = new PointPair(txd, dop.Position);
pp.Tag = String.Format("{0}\n{1} " + Localization.PDOP + ": {2:0.000}", svs, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), dop.Position);
DOPData[4].Add(pp);
// repeat for the Time DOP
pp = new PointPair(txd, dop.Time);
pp.Tag = String.Format("{0}\n{1} " + Localization.TDOP + ": {2:0.000}", svs, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), dop.Time);
DOPData[5].Add(pp);
// repeat for the Geometric DOP
pp = new PointPair(txd, dop.Geometric);
pp.Tag = String.Format("{0}\n{1} " + Localization.GDOP + ": {2:0.000}", svs, evaluateTime.ToDateTime().ToString("M/d/yyyy, h:mm tt"), dop.Geometric);
DOPData[6].Add(pp);
// Notice here that the different DOP values (East, North, etc) were denoted by the dop.X, dop.Y etc. This is because the
// DOP values could be in any coordinate system. In our case, we're in the ENU coordinate system an X represents East, Y
// represents North, Z represents Vertical, XY represents horizontal. You can change the reference frame the DOP is reported in
// but you will then have to understand that the dop.X value corresponds to your X-defined axis and so on.
}
catch
{
// Do Nothing here - we just won't add the data to the data list
}
// update the progress bar - we're done with this time step!
progressBar1.PerformStep();
}
// finally update the graphs
UpdateDopGraph();
updateAzElGraph();
// reset the progress bar
progressBar1.Value = 0;
// and set the appropriate button states
SetControlStates(true);
}
/// <summary>
/// Create another ground facility with a sensor dome, and a rotating sensor inside the dome.
/// </summary>
private void CreateSensorDome()
{
// Define the location of the facility using cartographic coordinates.
var locationPoint = new PointCartographic(m_earth, new Cartographic(Trig.DegreesToRadians(-122.3), Trig.DegreesToRadians(46), 456.359));
m_sensorDome = new Platform
{
Name = "Sensor Dome",
LocationPoint = locationPoint,
OrientationAxes = new AxesEastNorthUp(m_earth, locationPoint),
};
// Set the identifier for the facility in the CZML document.
m_sensorDome.Extensions.Add(new IdentifierExtension("SensorDome"));
// Define the sensor geometry.
var dome = new ComplexConic();
dome.SetHalfAngles(0.0, Math.PI);
dome.SetClockAngles(0.0, Math.PI * 2);
dome.Radius = 10000.0;
m_sensorDome.Extensions.Add(new FieldOfViewExtension(dome));
// Configure graphical display of the sensor dome.
m_sensorDome.Extensions.Add(new FieldOfViewGraphicsExtension(new SensorFieldOfViewGraphics
{
DomeSurfaceMaterial = new GridMaterialGraphics
{
Color = Color.White,
CellAlpha = 0.1,
},
}));
// Define a rotating axes.
var rotatingAxes = new AxesLinearRate
{
ReferenceAxes = new AxesEastNorthUp(m_earth, locationPoint),
ReferenceEpoch = m_epoch,
InitialRotation = UnitQuaternion.Identity,
SpinAxis = UnitCartesian.UnitZ,
InitialRotationalVelocity = Trig.DegreesToRadians(5.0), // 5 degrees per second
RotationalAcceleration = 0.0,
};
// Define a rotation around X.
UnitQuaternion quaternion = new UnitQuaternion(new AngleAxisRotation(Math.PI / 3.0, UnitCartesian.UnitX));
// Define an angular offset for the rotating axes.
var rotatedOffsetAxes = new AxesFixedOffset(rotatingAxes, quaternion);
m_rotatingSensor = new Platform
{
Name = "Rotating Sensor",
LocationPoint = locationPoint,
OrientationAxes = rotatedOffsetAxes
};
// Set the identifier for the sensor in the CZML document.
m_rotatingSensor.Extensions.Add(new IdentifierExtension("RotatingSensor"));
// Define the sensor geometry.
m_rotatingSensor.Extensions.Add(new FieldOfViewExtension(new RectangularPyramid
{
XHalfAngle = Trig.DegreesToRadians(30),
YHalfAngle = Trig.DegreesToRadians(30),
Radius = 10000.0,
}));
// Configure graphical display of the sensor.
m_rotatingSensor.Extensions.Add(new FieldOfViewGraphicsExtension(new SensorFieldOfViewGraphics
{
DomeSurfaceMaterial = new GridMaterialGraphics
{
Color = Color.Green,
CellAlpha = 0.5,
},
LateralSurfaceMaterial = new GridMaterialGraphics
{
Color = Color.Pink,
CellAlpha = 0.5,
},
IntersectionColor = Color.White,
ShowIntersection = true,
ShowEllipsoidHorizonSurfaces = true,
}));
}
