public override AZELCoordinate CoordinateAtTime(decimal elapsedTime, AZELCoordinate startCoordinates)
{
if (elapsedTime > 0)
{
DateTime currentTime = startTime.AddSeconds((double)elapsedTime);
AASharp.AAS2DCoordinate celestialLocation = CelestialLocation.CelestialObjectSwitch(celestialObject, currentTime);
return(new AZELCoordinate((decimal)celestialLocation.X, (decimal)celestialLocation.Y));
}
else
{
return(startCoordinates);
}
}
public void ProcessInstructionInput(Instruction instruction, AZELCoordinate startCoords)
{
TimeSpan interval = instruction.destinationTime - DateTime.Now;
// Some kind of global call that gets the current position from the last read encoder values
// For now, populate with Form Encoder
// Set Start time to now
instruction.setStartTime(DateTime.Now);
for (int i = 0; i < interval.TotalSeconds; i++)
{
trajectory.Add(new DiscreteCommand(instruction.CoordinateAtTime(i, startCoords), i));
}
}
public override AZELCoordinate CoordinateAtTime(decimal elapsedTime, AZELCoordinate startCoordinates)
{
int timeInterval = (int)destinationTime.Subtract(startTime).TotalSeconds;
if (timeInterval > 0 && elapsedTime > 0)
{
decimal mAZ = (destinationCoordinates.azimuth - startCoordinates.azimuth) / timeInterval;
decimal mEL = (destinationCoordinates.elevation - startCoordinates.elevation) / timeInterval;
return(new AZELCoordinate(
(mAZ * elapsedTime) + startCoordinates.azimuth,
(mEL * elapsedTime) + startCoordinates.elevation
));
}
else
{
return(startCoordinates);
}
}
public override AZELCoordinate CoordinateAtTime(decimal elapsedTime, AZELCoordinate startCoordinates)
{
int destinationElapsedTime = destinationTime.Subtract(startTime).Seconds;
if (destinationElapsedTime > 0 && elapsedTime > 0)
{
decimal mAZ = (destinationCoordinates.azimuth - startCoordinates.azimuth) / destinationElapsedTime;
decimal mEL = (destinationCoordinates.elevation - startCoordinates.elevation) / destinationElapsedTime;
return(new AZELCoordinate(
(mAZ * elapsedTime) + startCoordinates.azimuth,
(mEL * elapsedTime) + startCoordinates.elevation
));
}
else
{
return(startCoordinates);
}
}
public override AZELCoordinate CoordinateAtTime(decimal elapsedTime, AZELCoordinate startCoordinates)
{
int destinationElapsedTime = destinationTime.Subtract(startTime).Seconds;
if (destinationElapsedTime > 0 && elapsedTime > 0)
{
// This is wrong, we have to actually find arc length
AZELCoordinate result = new AZELCoordinate(0, 0);
decimal b = destinationCoordinates.azimuth - startCoordinates.azimuth;
decimal timeDone = elapsedTime / destinationElapsedTime;
decimal azDone = timeDone * b;
result.elevation = body.height * (timeDone * timeDone) / (b * b);
result.azimuth = azDone + startCoordinates.azimuth;
return(result);
}
else
{
return(startCoordinates);
}
}
public override AZELCoordinate CoordinateAtTime(decimal elapsedTime, AZELCoordinate startCoordinates)
{
int timeInterval = (int)destinationTime.Subtract(startTime).TotalSeconds;
if (timeInterval > 0 && elapsedTime > 0)
{
// Assume change in azimuth and change in elevation are both positive
decimal dAZ = Math.Abs(destinationCoordinates.azimuth - startCoordinates.azimuth);
decimal dEL = Math.Abs(destinationCoordinates.elevation - startCoordinates.elevation);
// Every DriftScan must be at least one change in azimuth across
decimal pathLength = dAZ;
// Track how much change in elevation is left
decimal remainingEL = dEL;
while (remainingEL > 2 * SCAN_DROP_DEGREES)
{
pathLength += ((2 * dAZ) + (2 * SCAN_DROP_DEGREES));
remainingEL -= (2 * SCAN_DROP_DEGREES);
}
// Ignore this case for now (assume the difference in position is an
// exact interval of 2*SCAN_DROP_DEGREES)
// pathLength += remainingEL;
decimal portionDone = pathLength * (elapsedTime / timeInterval);
AZELCoordinate cumulative = new AZELCoordinate(0, 0);
decimal accPath = 0;
decimal sequence = 0;
while (true)
{
switch (sequence)
{
case 0:
if (portionDone - accPath > dAZ)
{
accPath += dAZ;
}
else
{
cumulative.azimuth = portionDone - accPath;
return(cumulative);
}
break;
case 1:
if (portionDone - accPath > SCAN_DROP_DEGREES)
{
accPath += SCAN_DROP_DEGREES;
cumulative.elevation += SCAN_DROP_DEGREES;
}
else
{
cumulative.elevation += portionDone - accPath;
cumulative.azimuth = dAZ;
return(cumulative);
}
break;
case 2:
if (portionDone - accPath > dAZ)
{
accPath += dAZ;
}
else
{
cumulative.azimuth = dAZ - portionDone + accPath;
return(cumulative);
}
break;
case 3:
if (portionDone - accPath > SCAN_DROP_DEGREES)
{
accPath += SCAN_DROP_DEGREES;
cumulative.elevation += SCAN_DROP_DEGREES;
}
else
{
cumulative.elevation += portionDone - accPath;
cumulative.azimuth = 0;
return(cumulative);
}
break;
}
sequence = (sequence + 1) % 4;
}
}
else
{
return(startCoordinates);
}
}
public ScanInstruction(decimal az, decimal el, DateTime destTime) : base(destTime)
{
destinationCoordinates = new AZELCoordinate(az, el);
}
// Abstract implementation public abstract AZELCoordinate CoordinateAtTime(decimal dt, AZELCoordinate curr);
public Instruction(AZELCoordinate destCoords, DateTime destTime)
{
destinationCoordinates = destCoords;
destinationTime = destTime;
}
public override AZELCoordinate CoordinateAtTime(decimal elapsedTime, AZELCoordinate startCoordinates)
{
int destinationElapsedTime = destinationTime.Subtract(startTime).Seconds;
if (destinationElapsedTime > 0 && elapsedTime > 0)
{
decimal dAZ = destinationCoordinates.azimuth - startCoordinates.azimuth;
decimal dEL = destinationCoordinates.elevation - startCoordinates.elevation;
decimal pathLength = Math.Abs(dAZ);
decimal remainingEL = Math.Abs(dEL);
while (remainingEL > 2 * SCAN_DROP_DEGREES)
{
pathLength += (2 * Math.Abs(dAZ) + 2 * SCAN_DROP_DEGREES);
remainingEL -= (2 * SCAN_DROP_DEGREES);
}
// Ignore this case for now (assume the difference in position is an
// exact interval of 2*SCAN_DROP_DEGREES + 1)
//pathLength += remainingEL;
decimal portionDone = pathLength * (elapsedTime / destinationElapsedTime);
AZELCoordinate cumulative = new AZELCoordinate(0, 0);
decimal accPath = Math.Abs(dAZ);
decimal dDR = dEL >= 0 ? SCAN_DROP_DEGREES : -SCAN_DROP_DEGREES;
decimal dIA = 0;
while (true)
{
if (portionDone - accPath > Math.Abs(dAZ))
{
dIA = 1 - dIA;
accPath += Math.Abs(dAZ);
}
else
{
cumulative.azimuth = portionDone - accPath * (dAZ >= 0 ? 1 : -1);
Console.WriteLine(
"returning " + cumulative.azimuth.ToString() + " : " + cumulative.elevation.ToString()
);
return(cumulative);
}
if (portionDone - accPath > SCAN_DROP_DEGREES)
{
cumulative.elevation += dDR;
accPath += SCAN_DROP_DEGREES;
}
else
{
cumulative.elevation += portionDone - accPath;
Console.WriteLine(
"returning " + cumulative.azimuth.ToString() + " : " + cumulative.elevation.ToString()
);
return(cumulative);
}
Console.WriteLine(
accPath.ToString() + " : " + portionDone.ToString() + " : " +
cumulative.azimuth.ToString() + " : " + cumulative.elevation.ToString()
);
}
}
else
{
return(startCoordinates);
}
}
public DiscreteCommand(AZELCoordinate coords, decimal ds)
{
coordinates = coords;
diffSecs = ds;
}
