public linearFeatureCoverageSummary readLinearFeatureCoverageData(XmlReader tr, String ProjectName) { /////////////////////////////////////////////////////////////////////// //read in the input kml describing the line feature coverage /////////////////////////////////////////////////////////////////////// //input kml linear feature -- dont need this //project map bounds //path information (trigger spacing, origin, UTM zone) //table of information -- need some of this //takeoff airport -- dont need this //along-path map bounds -- need this //path specific data -- dont need this //smoothed trajectory -- need this //center projection -- dont need //image endpoints -- dont need bool completedreadingProjectMapBounds = false; bool completedReadingPathInformation = false; bool completedReadingSmoothedPathPoints = false; linearFeatureCoverageSummary LFSummary = new linearFeatureCoverageSummary(); LFSummary.gridOrigin = new PointD(); //get the project map bounds //how do I exit this loop ??? //TODO: test to see if the kml file projectName is the same as the kml fileName while (tr.Read() && !completedreadingProjectMapBounds) { if (tr.EOF) break; if (tr.IsStartElement() && tr.Name == "GroundOverlay") { while (tr.Read() && !completedreadingProjectMapBounds) { if (tr.IsStartElement() && tr.Name == "name") { tr.Read(); //we are looking for the name "project Map" where we will get the map bounds if (tr.Value == "Project Map") { int numBounds = 0; while (tr.Read() && !completedreadingProjectMapBounds) { if (tr.IsStartElement() && tr.Name == "north") { tr.Read(); LFSummary.ProjectImage.northDeg = Convert.ToDouble(tr.Value); numBounds++; } if (tr.IsStartElement() && tr.Name == "south") { tr.Read(); LFSummary.ProjectImage.southDeg = Convert.ToDouble(tr.Value); numBounds++; } if (tr.IsStartElement() && tr.Name == "east") { tr.Read(); LFSummary.ProjectImage.eastDeg = Convert.ToDouble(tr.Value); numBounds++; } if (tr.IsStartElement() && tr.Name == "west") { tr.Read(); LFSummary.ProjectImage.westDeg = Convert.ToDouble(tr.Value); numBounds++; } if (numBounds == 4) completedreadingProjectMapBounds = true; } } } } } }// end of: get the project map bounds if (tr.EOF) { MessageBox.Show("Bad map bounds format for the input kml file -- exiting"); Environment.Exit(-1); } int numPathInfo = 0; while (tr.Read() && !completedReadingPathInformation) { if (tr.EOF) break; if (tr.IsStartElement() && tr.Name == "downRangePhotoSpacingMeters") { tr.Read(); LFSummary.photocenterSpacing = Convert.ToDouble(tr.Value); numPathInfo++; } if (tr.IsStartElement() && tr.Name == "numberOfPaths") { tr.Read(); LFSummary.numberParallelPaths = Convert.ToInt32(tr.Value); numPathInfo++; } if (tr.IsStartElement() && tr.Name == "UTMZone") { tr.Read(); LFSummary.UTMZone = tr.Value; numPathInfo++; } if (tr.IsStartElement() && tr.Name == "gridOriginUTMNorthing") { tr.Read(); LFSummary.gridOrigin.Y = Convert.ToDouble(tr.Value); numPathInfo++; } if (tr.IsStartElement() && tr.Name == "gridOriginUTMEasting") { tr.Read(); LFSummary.gridOrigin.X = Convert.ToDouble(tr.Value); numPathInfo++; } if (tr.IsStartElement() && tr.Name == "proNavGain") { tr.Read(); LFSummary.proNavGain = Convert.ToDouble(tr.Value); numPathInfo++; } if (tr.IsStartElement() && tr.Name == "rabbitAheadDistance") { tr.Read(); LFSummary.plannedRabbitDistanceAhead = Convert.ToDouble(tr.Value); numPathInfo++; } if (tr.IsStartElement() && tr.Name == "flightAltAGLft") { tr.Read(); LFSummary.flightAltAGLft = Convert.ToDouble(tr.Value); numPathInfo++; } if (numPathInfo == 8)completedReadingPathInformation = true; } // end of: get the path info if (tr.EOF) { MessageBox.Show("Bad path info format for the input kml file -- exiting"); Environment.Exit(-1); } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //read in the bounds of the mission images ProjectName_Background\background_YY.jpg ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// LFSummary.paths = new List<pathDescription>(); int numPathsProcessedForBounds = 0; while (tr.Read() && numPathsProcessedForBounds < LFSummary.numberParallelPaths) { if (tr.EOF) break; //read til we get the top of the next set of image bounds for a path if (tr.IsStartElement() && tr.Name == "numBGImagesThisPath") { tr.Read(); int numImagesThisPath = Convert.ToInt32(tr.Value); int pathImageBoundsRead = 0; pathDescription path = new pathDescription(); path.imageBounds = new List<ImageBounds>(); //read off a complete set of bounds for a path while (tr.Read() && pathImageBoundsRead < numImagesThisPath) //loop over all image bounds in the folder { //read a complete set of image bounds ImageBounds ib = new ImageBounds(); // fill an image bounds structure int numBounds = 0; while (tr.Read() && numBounds < 4) { if (tr.IsStartElement() && tr.Name == "north") { tr.Read(); ib.northDeg = Convert.ToDouble(tr.Value); numBounds++; } if (tr.IsStartElement() && tr.Name == "east") { tr.Read(); ib.eastDeg = Convert.ToDouble(tr.Value); numBounds++; } if (tr.IsStartElement() && tr.Name == "south") { tr.Read(); ib.southDeg = Convert.ToDouble(tr.Value); numBounds++; } if (tr.IsStartElement() && tr.Name == "west") { tr.Read(); ib.westDeg = Convert.ToDouble(tr.Value); numBounds++; } } path.imageBounds.Add(ib); pathImageBoundsRead++; } LFSummary.paths.Add(path); numPathsProcessedForBounds++; } } //end of reading in the map bounds along the paths if (tr.EOF) { MessageBox.Show("Bad path info format for the input kml file -- exiting"); Environment.Exit(-1); } //read in the smoothed trajectory for each path UTM2Geodetic utm = new UTM2Geodetic(); //we are ready to read off the coordinates of the smoothed trajectory int numPathsProcessed = 0; while (tr.Read() && !completedReadingSmoothedPathPoints) { if (tr.EOF) break; if (tr.IsStartElement() && tr.Name == "name") { tr.Read(); //we will encounter this statement "numberParallelPaths" times if (tr.Value == "Smoothed Linear Feature Trajectory") { pathDescription path = LFSummary.paths[numPathsProcessed]; path.pathGeoDeg = new List<PointD>(); path.pathUTM = new List<PointD>(); path.commandedAltAlongPath = new List<double>(); bool thisPathComplete = false; while (tr.Read() && !thisPathComplete) { //locate the coordinate tag for this path if (tr.IsStartElement() && tr.Name == "coordinates") { tr.Read(); //read the complete coordinate dataset char[] delimiterChars = { ',', ' ', '\t', '\n', '\r' }; //these delimiters were determined by looking at a file ... //create a character string with all characters separated by a delimeter string[] coordinateValues = tr.Value.ToString().Split(delimiterChars); //the "value" is the text between the <coordinates> and </coordinates> //below we read the complete string value and split it into separate substrings -- ugly but it works //the substrings contain the individual coordinate values with some ""s and the heigts are "0". //get the quantitative lat/long values from the text array ... there are a number of ""s in the text file ... //each Google point has three values : longitude, Latitude, height -- we assume the height is zero here int k = 0; int i = 0; while (i < coordinateValues.Count()) { if (coordinateValues[i] != "") { double lat = Convert.ToDouble(coordinateValues[i + 1]); double lon = Convert.ToDouble(coordinateValues[i]); double alt = Convert.ToDouble(coordinateValues[i + 2]); path.pathGeoDeg.Add(new PointD(lon, lat) ); path.commandedAltAlongPath.Add(alt); //convert the geodetic to UTM double UTMNorthing = 0.0, UTMEasting = 0.0; utm.LLtoUTM(lat * utm.Deg2Rad, lon * utm.Deg2Rad, ref UTMNorthing, ref UTMEasting, ref LFSummary.UTMZone, true); path.pathUTM.Add(new PointD(UTMEasting, UTMNorthing)); k++; //index of the storage array //increment the split array by 3 because the points are lat,lon,height i += 3; //increment by 3 to get the next coordinate } else i++; //here we skip the ""s in the text array } thisPathComplete = true; numPathsProcessed++; } } //end of while numPathsProcessed < LFSummary.numberParallelPaths if (numPathsProcessed == LFSummary.numberParallelPaths) completedReadingSmoothedPathPoints = true; } } } if (tr.EOF) { MessageBox.Show("Bad smoothed trajectory format for the input kml file -- exiting"); Environment.Exit(-1); } return LFSummary; ////////////////////////////////////////////////////////////// // the Project Summary for Waldo_FCS is Complete ////////////////////////////////////////////////////////////// }
public List<endPoints> UpdateFlightLinesPerPriorFlownMissions(int missionNumber) { ///////////////////////////////////////////////////////////////////////////////////////////// //use the MissionUpdateFlightlines structure (fromn the constructor) to update the flight lines //the new flight lines replace the old flight lines //the initial prior flightline analysis provided a structure //that contained only data from the flown missions. //This procedure creates a replica of the mission plan flight lines, //for a specific mission, that are adjusted to remove the prior flown lines (and segments) ///////////////////////////////////////////////////////////////////////////////////////////// UTM2Geodetic utm = new UTM2Geodetic(); //needs to be in a utility procedure available to all in the solution //test to see if pre-flown mission dataset contain this mission int preFlownMissionIndex = 0; //mission index from the flightline analysis bool thisMissionWasPreflown = false; foreach (MissionUpdateFlightlines msnUpdate in projUpdate.msnUpdate) { if (missionNumber == msnUpdate.missionNumber) { thisMissionWasPreflown = true; break; } preFlownMissionIndex++; } //////////////////////////////////////////////////////////////////////////////////////////// //this is the updates flight line dataset that replicates the data in the original plan List<endPoints> FLUpdateList = new List<endPoints>(); //return value //////////////////////////////////////////////////////////////////////////////////////////// //if this mission was not reflown -- just copy the old data to the replica if (!thisMissionWasPreflown) { for (int iFL = 0; iFL < projSum.msnSum[missionNumber].numberOfFlightlines; iFL++) FLUpdateList.Add(projSum.msnSum[missionNumber].FlightLinesCurrentPlan[iFL]); return FLUpdateList; } //if here, the mission was reflown -- generate the replica. //NOTE: all flightlines were likely not preflown -- just a part of them. //this is an index into the preflown-analysis structure indicating the reflown line int nextFlownFL = 0; //cycle through ALL flight lines for this mission for (int iFL = 0; iFL < projSum.msnSum[missionNumber].numberOfFlightlines; iFL++) { bool thisFlightLineWasPreflown = false; //the "if" below skips the checks on the remaining lines if we are beyond the nuber of reflown lines if (nextFlownFL >= projUpdate.msnUpdate[preFlownMissionIndex].flightLineUpdate.Count) thisFlightLineWasPreflown = false; //this is the test to see if we have reflown this line = iFL else if (iFL == projUpdate.msnUpdate[preFlownMissionIndex].flightLineUpdate[nextFlownFL].FLNumber) thisFlightLineWasPreflown = true; if (!thisFlightLineWasPreflown) //if not reflown -- just copy the old data { FLUpdateList.Add(projSum.msnSum[missionNumber].FlightLinesCurrentPlan[iFL]); } else //create a new flightline dataset { // NOTE: we convert the initial geodetic ends to UTM for the now endpoint computations // this is to maintain precision //found a pre-flown flightline PointD FLendGeo = projSum.msnSum[missionNumber].FlightLinesCurrentPlan[iFL].end; PointD FLstartGeo = projSum.msnSum[missionNumber].FlightLinesCurrentPlan[iFL].start; PointD FLendUTM = new PointD(0.0, 0.0); PointD FLstartUTM = new PointD(0.0, 0.0); //convert the original planned flight line ends to UTM -- could pass these in from the original plan //NOTTE: maintain the same utm zone fro the mission planning -- else big trouble!!! utm.LLtoUTM(FLstartGeo.Y * utm.Deg2Rad, FLstartGeo.X * utm.Deg2Rad, ref FLstartUTM.Y, ref FLstartUTM.X, ref projSum.UTMZone, true); utm.LLtoUTM(FLendGeo.Y * utm.Deg2Rad, FLendGeo.X * utm.Deg2Rad, ref FLendUTM.Y, ref FLendUTM.X, ref projSum.UTMZone, true); //below are the start and end photocenters as determined from the prior-flown mission analysis //NOTE: the start is geodetically fixed -- e.g., at the south end for a NS flightline int startPhotoCenter = projUpdate.msnUpdate[preFlownMissionIndex].flightLineUpdate[nextFlownFL].early; int endPhotoCenter = projUpdate.msnUpdate[preFlownMissionIndex].flightLineUpdate[nextFlownFL].late; PointD newStartUTM = new PointD(0.0, 0.0); PointD newEndUTM = new PointD(0.0, 0.0); // just a comparison of the computed and input flightline lengths ... it checks: JEK 1/26/2012 double FLMag1 = projSum.msnSum[missionNumber].FlightLinesCurrentPlan[iFL].FLLengthMeters; //double FLMag2 = Math.Sqrt((FLendUTM.X - FLstartUTM.X) * (FLendUTM.X - FLstartUTM.X) + (FLendUTM.Y - FLstartUTM.Y) * (FLendUTM.Y - FLstartUTM.Y)); //proportionally space the new photocenters along the origional flightine -- in UTM space newStartUTM = FLstartUTM + (startPhotoCenter * projSum.downrangeTriggerSpacing / FLMag1) * (FLendUTM - FLstartUTM); newEndUTM = FLstartUTM + (endPhotoCenter * projSum.downrangeTriggerSpacing / FLMag1) * (FLendUTM - FLstartUTM); PointD newStartGeo = new PointD(0.0, 0.0); PointD newEndGeo = new PointD(0.0, 0.0); //now convert them back to geodetic utm.UTMtoLL(newStartUTM.Y, newStartUTM.X, projSum.UTMZone, ref newStartGeo.Y, ref newStartGeo.X); utm.UTMtoLL(newEndUTM.Y, newEndUTM.X, projSum.UTMZone, ref newEndGeo.Y, ref newEndGeo.X); endPoints epts = new endPoints(); //temporary structure //fill the temporary structure //this used the 2D geometry and will work for NS or EW flight lines epts.FLLengthMeters = (endPhotoCenter - startPhotoCenter) * projSum.downrangeTriggerSpacing; epts.end = newEndGeo; epts.start = newStartGeo; //this is the global project flight line number -- not a local number used for this mission epts.FlightLineNumber = projSum.msnSum[missionNumber].FlightLinesCurrentPlan[iFL].FlightLineNumber; //below is important to allow flight line updates that include partial flown lines. //all photocenters are given a unique name in the original flight plan //we must keep this original name for the photocenters //the names are based on the distance from the geodetic fixed otiginal start location // so we have to keep the offset for the updated flight lines from the original plan epts.photoCenterOffset = startPhotoCenter; //fill the replical flight line structure FLUpdateList.Add(epts); //increment the index into the preflown flightline analysis structure nextFlownFL++; } //end of filling the new flightline record } //end of filling the individual flight lines (iFL) return FLUpdateList; //filled replica of the original flightplan fllightlines for this mission }
public CurrentFlightLineGeometry( int missionNumber, int flightLineNumber, ProjectSummary _ps, bool[] _priorFlownFLs) { //////////////////////////////////////////////////////////////////// //do all the stuff that does not vary with the aircraft location //////////////////////////////////////////////////////////////////// ps = _ps; priorFlownFLs = _priorFlownFLs; UTM2Geodetic utm = new UTM2Geodetic(); Rad2Deg = 180.0 / Math.Acos(-1.0); Deg2Rad = Math.Acos(-1.0) / 180.0; FLendUTM = new PointD(0.0, 0.0); FLstartUTM = new PointD(0.0, 0.0); FLP1endUTM = new PointD(0.0, 0.0); FLP1startUTM = new PointD(0.0, 0.0); //set up the parameters of the flight line independent of the aircraft Platform FLendGeo = ps.msnSum[missionNumber].FlightLinesCurrentPlan[flightLineNumber].end; FLstartGeo = ps.msnSum[missionNumber].FlightLinesCurrentPlan[flightLineNumber].start; //utm flight line endpoints utm.LLtoUTM(FLstartGeo.Y * Deg2Rad, FLstartGeo.X * Deg2Rad, ref FLstartUTM.Y, ref FLstartUTM.X, ref ps.UTMZone, true); utm.LLtoUTM(FLendGeo.Y * Deg2Rad, FLendGeo.X * Deg2Rad, ref FLendUTM.Y, ref FLendUTM.X, ref ps.UTMZone, true); // the number 10 means that the semi-infinite line extensions are 10 times longer than the flightline .... PointD del = 10 * (FLendGeo - FLstartGeo); //semi-infinite line use for drawing a line extending beyond the FL ends semiInfiniteFLstartGeo = FLstartGeo - del; semiInfiniteFLendGeo = FLendGeo + del; FLlengthSq = (FLendUTM.X - FLstartUTM.X) * (FLendUTM.X - FLstartUTM.X) + (FLendUTM.Y - FLstartUTM.Y) * (FLendUTM.Y - FLstartUTM.Y); FLlengthMeters = Math.Sqrt(FLlengthSq); start2EndFlightLineUnit = new PointD((FLendUTM.X - FLstartUTM.X) / FLlengthMeters, (FLendUTM.Y - FLstartUTM.Y) / FLlengthMeters); //next flight line data -- what happens on the last flightlne ?? if (flightLineNumber < (ps.msnSum[missionNumber].numberOfFlightlines-1) ) { //this is redundant with code where the currentFlightLine is switched // nextFlightlineNumber should be kept as a part of flightline geometry nextFlightlineNumber = flightLineNumber + 1; while (priorFlownFLs[nextFlightlineNumber]) { if (nextFlightlineNumber >= priorFlownFLs.Count() - 1) break; nextFlightlineNumber++; } PointD FLP1endGeo = ps.msnSum[missionNumber].FlightLinesCurrentPlan[nextFlightlineNumber].end; PointD FLP1startGeo = ps.msnSum[missionNumber].FlightLinesCurrentPlan[nextFlightlineNumber].start; utm.LLtoUTM(FLP1startGeo.Y * Deg2Rad, FLP1startGeo.X * Deg2Rad, ref FLP1startUTM.Y, ref FLP1startUTM.X, ref ps.UTMZone, true); utm.LLtoUTM(FLP1endGeo.Y * Deg2Rad, FLP1endGeo.X * Deg2Rad, ref FLP1endUTM.Y, ref FLP1endUTM.X, ref ps.UTMZone, true); //works for all flightline aspects -- assumes the flightlines are parallel //project start-to-start (RS) and end-to-end (RE) vectors onto current flightline start-to-end unit vector double delSX = FLP1startUTM.X - FLstartUTM.X; double delSY = FLP1startUTM.Y - FLstartUTM.Y; double RS = start2EndFlightLineUnit.X * delSX + start2EndFlightLineUnit.Y * delSY; double delEX = FLP1endUTM.X - FLendUTM.X; double delEY = FLP1endUTM.Y - FLendUTM.Y; double RE = start2EndFlightLineUnit.X * delEX + start2EndFlightLineUnit.Y * delEY; if (RS < 0.0) ExtensionBeforeStart = -RS; if (RE > 0.0) ExtensionBeyondEnd = RE; //below works for only NS missions //if (FLP1endUTM.Y > FLendUTM.Y) ExtensionBeyondEnd = FLP1endUTM.Y - FLendUTM.Y; //if (FLP1startUTM.Y < FLstartUTM.Y) ExtensionBeforeStart = FLstartUTM.Y - FLP1startUTM.Y; } //the "+1" ensures a photocenter at the start of the flight line and at the end of the flight line. //The start/ends of the line have been placed on a grid with fixed downrange spacing for the complete project numPhotoCenters = Convert.ToInt32( FLlengthMeters / ps.downrangeTriggerSpacing) + 1; //used to record the successful completion of a photocenter //set to true after we have recorded the image on the storage media successfulImagesCollected = new bool[numPhotoCenters+10]; //store the photocenter locations in pixel coordinates TriggerPoints = new Point[numPhotoCenters + 10]; for (int i = 0; i < numPhotoCenters + 10; i++) { successfulImagesCollected[i] = false; TriggerPoints[i] = new Point(); } }