コード例 #1
0
        public COVERAGE_TYPE polygonGeometry()
        {
            ///////////////////////////////////////////////////////////////////////
            // get the mean polygon location and the polygon area
            // convert all vertices to UTM
            // get the UTM zone that will be used
            // get recangular bounding box
            // determine the orientation of the point-scatter covariance ellipse
            ///////////////////////////////////////////////////////////////////////
            utm = new UTM2Geodetic();  //class for LL to UTM conversion

            for (int i = 0; i < polygons.Count; i++)
            {
                //local copy of the polygon -- re-inserted into the polygon list at the end of this procedure
                Polygon p = polygons[i];

                int numLatLonPoints = p.latitudeDeg.Count;

                //mean Northing and Easting from mean lat/lon -- also use this to get the UTMZone that will be held fixed for this polygon
                p.meanNorthing = 0.0;
                p.meanEasting = 0.0;

                //NOTE:  get the UTMZone here (for the polygon mean location) that will be used for the whole project
                utm.LLtoUTM(p.meanLatDeg * Deg2Rad, p.meanLonDeg * Deg2Rad, ref p.meanNorthing, ref p.meanEasting, ref p.UTMZone, false);
                //the UTM zone will be held constant across the polygon points -- deals with polys that cross UTM zones

                //get the Northing and Easting from the lat/lon poly points
                double northing = 0.0, easting = 0.0;
                p.maxNorthing = -9999999.0; p.maxEasting = -999999999.0; p.minNorthing = 999999999.0; p.minEasting = 99999999999.0;
                p.maxLatDeg = -99999.0; p.maxLonDeg = -9999999.0; p.minLatDeg = 99999.0; p.minLonDeg = 999999.0;
                double CovXX = 0.0, CovYY = 0.0, CovXY = 0.0;  //covariance of the UTM poly points
                for (int ipnts = 0; ipnts < numLatLonPoints; ipnts++)
                {
                    utm.LLtoUTM(p.latitudeDeg[ipnts] * Deg2Rad, p.longitudeDeg[ipnts] * Deg2Rad, ref northing, ref easting, ref p.UTMZone, true);
                    p.Northing.Add(northing); p.Easting.Add(easting);

                    if (northing > p.maxNorthing) p.maxNorthing = northing;
                    if (northing < p.minNorthing) p.minNorthing = northing;
                    if (easting > p.maxEasting) p.maxEasting = easting;
                    if (easting < p.minEasting) p.minEasting = easting;

                    if (p.latitudeDeg[ipnts]  > p.maxLatDeg) p.maxLatDeg = p.latitudeDeg[ipnts];
                    if (p.latitudeDeg[ipnts]  < p.minLatDeg) p.minLatDeg = p.latitudeDeg[ipnts];
                    if (p.longitudeDeg[ipnts] > p.maxLonDeg) p.maxLonDeg = p.longitudeDeg[ipnts];
                    if (p.longitudeDeg[ipnts] < p.minLonDeg) p.minLonDeg = p.longitudeDeg[ipnts];

                    //covariance elements used to compute the principal axes of the polygon
                    //here we are assuming a north (X), east (Y), down (Z) corrdinatate system
                    CovYY += (easting  - p.meanEasting)  * (easting - p.meanEasting);
                    CovXX += (northing - p.meanNorthing) * (northing - p.meanNorthing);
                    CovXY += (easting  - p.meanEasting)  * (northing - p.meanNorthing);
                }

                CovYY /= 1000*numLatLonPoints;
                CovXX /= 1000*numLatLonPoints;
                CovXY /= 1000*numLatLonPoints;

                //Compute the orientation of the principal axis of the covariance ellipse
                //this is used to determine the best flying direction

                //eigenvalues of covariance matrix -- see below site for equations for eigenvalues/vectors for 2D matrix
                //    people.csail.mit.edu/bkph/articles/Eigenvectors.pdf
                double det = Math.Sqrt( (CovXX - CovYY)*(CovXX - CovYY) + 4.0 * CovXY * CovXY );
                double lambda1 = ( CovXX + CovYY +  det )/ 2.0;
                double lambda2 = ( CovXX + CovYY -  det )/ 2.0;
                //the larger of these is the length of the major axis
                //smaller is length of the minor axis

                //the angle associated with the larger eigenvalue is the angle of the major axis
                //eigenvectors should be 90 deg apart
                if (lambda1 > lambda2)
                {
                    //eigenvectors of covariance matrix
                    double eigen1X = 2.0 * CovXY;
                    double eigen1Y = CovYY - CovXX + det;
                    double ang1 = Math.Atan(eigen1Y / eigen1X) * Constants.Rad2Deg;
                    p.rotationAngleDeg = ang1;
                }
                else
                {
                    //eigenvectors of covariance matrix
                    double eigen2X = 2.0 * CovXY;
                    double eigen2Y = CovYY - CovXX - det;
                    double ang2 = Math.Atan(eigen2Y / eigen2X) * Constants.Rad2Deg;
                    p.rotationAngleDeg = ang2;
                }
                //reflect a negative major axis direction by 180 deg (major axis can go either direction)
                if (p.rotationAngleDeg < 0) p.rotationAngleDeg += 180.0;

                //this must be done after creating the UTM Northing & Easting from the geodetic coordinates
                polygonMath polyMath = new polygonMath(p.Easting, p.Northing, datasetFolder);

                //compute rectangle bounds using the principal axes
                double maxAlongPA = -9999999999, minAlongPA = 9999999999, distanceA = 0.0;
                double maxOrthoPA = -9999999999, minOrthoPA = 9999999999, distanceO = 0.0;
                for (int ipnts = 0; ipnts < numLatLonPoints; ipnts++)
                {
                    //note below that the X components is Northing and the Y components are Easting
                    //The "line" is defined by its origin and rotation angle (positive east of north)
                    //the "point" is the ipnts vertex of the polygon
                    distanceO = polyMath.distanceFromPoint2Line(  //distance orthogonal to the pricipal axis
                        new PointD(p.meanNorthing, p.meanEasting),
                        p.rotationAngleDeg,
                        new PointD(p.Northing[ipnts], p.Easting[ipnts]));
                    distanceA = polyMath.distanceFromPoint2Line(  //distance orthogonal to the pricipal axis
                        new PointD(p.meanNorthing, p.meanEasting),
                        p.rotationAngleDeg + 90,
                        new PointD(p.Northing[ipnts], p.Easting[ipnts]));

                    if (distanceA > maxAlongPA) maxAlongPA = distanceA;
                    if (distanceA < minAlongPA) minAlongPA = distanceA;
                    if (distanceO > maxOrthoPA) maxOrthoPA = distanceO;
                    if (distanceO < minOrthoPA) minOrthoPA = distanceO;
                }

                //length and width of a bounding box with long-side along principal axis
                //length should always be larger than the width
                double lengthKm = (maxAlongPA - minAlongPA) / 1000.0;
                double widthKm = (maxOrthoPA - minOrthoPA)  / 1000.0;
                //Constants.Log("Principal Axis bounding box: " + lengthKm.ToString("F1") + " X " + widthKm.ToString("F1"));
                //if (lengthKm < widthKm)
                //    MessageBox.Show("Principal axes of polygon not longer than minor axis");

                //principal axis direction is defined by p.rotationAngleDeg
                //set the corner of the principal axes bounding box to be negative-going along the major and minor axis
                //this corner will also become the origion of the flight line reference coordinate system
                //this will correspond to a south-east corner for a north-going princpal axis

                p.boundingBoxCornerNorthing =
                    Math.Cos(p.rotationAngleDeg * Constants.Deg2Rad) * (p.meanNorthing + minAlongPA) +
                    Math.Sin(p.rotationAngleDeg * Constants.Deg2Rad) * (p.meanEasting + minOrthoPA);
                p.boundingBoxCornerEasting =
                   -Math.Sin(p.rotationAngleDeg * Constants.Deg2Rad) * (p.meanNorthing + minAlongPA) +
                    Math.Cos(p.rotationAngleDeg * Constants.Deg2Rad) * (p.meanEasting + minOrthoPA);

                //TODO:  should just return the polygon points and fill the p structure after the return
                p.areasqkm = polyMath.areaOfPolygon();
                p.areasqmi = p.areasqkm * 1000000.0 / ((0.3048 * 5280.0) * (0.3048 * 5280.0));

                Constants.Log("");
                if (p.polyCoverageType == COVERAGE_TYPE.polygon)
                {
                    Constants.Log("Polygon area: " + p.areasqmi.ToString("F3") + "  (sqmi)   " + p.areasqkm.ToString("F3") + "  (sqkm)");
                }
                else if (p.polyCoverageType == COVERAGE_TYPE.linearFeature)
                {
                    double pathRange = polyMath.pathLength();
                    Constants.Log("Path length: " + (pathRange/0.3048/5280.0).ToString("F2") +
                        " (mi)  " + (pathRange/1000.0).ToString("F2") + " (km)");
                }
                Constants.Log("");

                ///////////////////////////////////////////////////////////////////////////////////////////////
                //write the summary information for this polygon
                //outfile.WriteLine();
                outfile.WriteLine("PolygonName:  {0}   PolyPoints= {1,4}  Area= {2,9:####.00} (kmsq) {3,9:####.00} (sqmi)",
                        p.PolygonName, numLatLonPoints.ToString(), p.areasqkm, p.areasqmi);
                //foreach (airport apt in apts)
                //       outfile.WriteLine("   {0,50}  distance (mi) {1,8:####.00}", apt.name, apt.distanceToPolyCenterMi);
                /////////////////////////////////////////////////////////////////////////////////////////////////

                //we have modified a copy of the polygon object -- re-insert it into the polygon list
                polygons[i] = p;
            }

            //NOTE: here we are assuming that all the coverage types are identical
            //generally we only use a single coverage for a mission plan session
            return polygons[0].polyCoverageType;
        }
コード例 #2
0
ファイル: GoogleMaps.cs プロジェクト: jekain314/KMLReader
        public void createBackgroundMapsForLinearFeature(List<LINEAR_FEATURE> linearFeatures, String UTMZone, bool downloadMap)
        {
            /////////////////TODO -- put in a input file
            ////////////////////////////////////////////////////////////////////////////
            double maxIncrementAlonPathMeters = 5.0 * 5280.0 * 0.3048; // 5.0 miles
            ////////////////////////////////////////////////////////////////////////////

            for (int iFeat = 0; iFeat < linearFeatures.Count; iFeat++)
            {
                LINEAR_FEATURE  linearFeature = linearFeatures[iFeat];

                polygonMath polyMath = new polygonMath(linearFeature.EastingProNavS, linearFeature.NorthingProNavS, datasetFolder);
                UTM2Geodetic utm = new UTM2Geodetic();

                linearFeature.NWMapCorner = new List<PointD>();
                linearFeature.SEMapCorner = new List<PointD>();
                linearFeature.mapNames = new List<string>();

                //find a deltaRange along the path < maxIncrementAlonPathMeters such that deltaRange * N = totalPathLength
                int nMaps = (int)(linearFeature.pathLength / maxIncrementAlonPathMeters);
                //above gives a number of increments such that one additional increment will fall outside the endpoint.
                double incrementAlongPath = linearFeature.pathLength / (nMaps + 1);
                //this gives an incerment that is < maxIncrementAlonPathMeters such that
                //there will be nMaps+1 increments that end exactly on the end of the path
                //We will need nMaps + 2 maps with one map at the beginning and one map at the end
                int totalMaps = nMaps + 2;

                //this lets us put N equispaced 10mix10mi maps along the path.
                for (int i = 0; i < totalMaps; i++)
                {

                    /////////////////////
                    //get a map
                    /////////////////////
                    //build up the URL to retrieve the Google Map -- see the above model for the syntax

                    //this zoom level gives ~ 10mi X 10mi
                    int zoom = 12;

                    //increment the path
                    PointD pap = polyMath.pointAlongPathFromStart(i * incrementAlongPath);

                    double latitude = 0.0, longitude = 0.0;
                    utm.UTMtoLL(pap.Y, pap.X, UTMZone, ref latitude, ref longitude);

                    setMap(zoom, new PointD(longitude, latitude));

                    /*  below used only to get the width & height of the returned map with zoom = 12
                    double NWNorthing = 0.0, NWEasting = 0.0;
                    double SENorthing = 0.0, SEEasting = 0.0;
                    utm.LLtoUTM(mapNWCornerCordinates.Y * Constants.Deg2Rad, mapNWCornerCordinates.X * Constants.Deg2Rad,
                        ref NWNorthing, ref NWEasting, ref UTMZone, true);
                    utm.LLtoUTM(mapSECornerCordinates.Y * Constants.Deg2Rad, mapSECornerCordinates.X * Constants.Deg2Rad,
                        ref SENorthing, ref SEEasting, ref UTMZone, true);

                    double mapNSDimensionMi = (NWNorthing - SENorthing) / 0.3048 / 5280.0;
                    double mapEWDimensionMi = (SEEasting  - NWEasting)  / 0.3048 / 5280.0;
                     * */

                    linearFeature.NWMapCorner.Add(mapNWCornerCordinates);
                    linearFeature.SEMapCorner.Add(mapSECornerCordinates);

                    String GoogleMapsURL = "http://maps.googleapis.com/maps/api/staticmap?center=" +
                                latitude.ToString() + "," +
                                longitude.ToString() + "&zoom=" + zoom.ToString() + "&size=640x480&sensor=false";

                    //this downloads a map that can be opened --- need to figure out the scaling...
                    //GoogleMapsURL = "http://dev.virtualearth.net/REST/v1/Imagery/Map/Road/Routes?wp.0=Seattle,WA;64;1&wp.1=Redmond,WA;66;2&key=" +
                    //    Constants.bingKey;

                    //set the file storage location
                    String backgroundImageFolder = datasetFolder + "\\" + polygonName + "_Background";
                    if (!Directory.Exists(backgroundImageFolder)) Directory.CreateDirectory(backgroundImageFolder);

                    String SaveToFile = backgroundImageFolder + "\\linearMap_" + iFeat.ToString("D2") +"_" + i.ToString("D3") + ".png";

                    if (downloadMap)
                    {
                        //get the file from the web using a webClient
                        getFileFromWeb(GoogleMapsURL, SaveToFile);
                    }

                    linearFeature.mapNames.Add(SaveToFile);

                }
            }
        }
コード例 #3
0
        public void expandPolygonVertices(double border)
        {
            for (int ipoly = 0; ipoly < polygons.Count; ipoly++)
            {
                Polygon p = polygons[ipoly];

                polygonMath polyMath = new polygonMath(p.Easting, p.Northing, datasetFolder);

                ////////////////////////////////////////////////////////////////////////////////////////////////////////
                //expand the client polygon with a border
                //these will become the expanded polygon points
                //note the origonal points are destroyed -- should save them
                List<double> EastingExp = new List<double>();
                List<double> NorthingExp = new List<double>();
                p.OriginalLatitudeDeg = new List<double>();
                p.OriginalLongitudeDeg = new List<double>();
                //double border = 500.0;  //added border in meters
                polyMath.expandedPoly(ref EastingExp, ref NorthingExp, border);

                //preserve the original polygon latitude and longitude
                for (int i = 0; i < EastingExp.Count; i++)
                {
                    p.OriginalLatitudeDeg.Add(p.latitudeDeg[i]);
                    p.OriginalLongitudeDeg.Add(p.longitudeDeg[i]);
                }

                //destroy the old lat-lon points and replace with the new expanded points
                p.latitudeDeg.Clear();
                p.longitudeDeg.Clear();
                p.Easting.Clear();
                p.Northing.Clear();
                for (int i = 0; i < EastingExp.Count; i++)
                {
                    if (NorthingExp[i] > p.maxNorthing) p.maxNorthing = NorthingExp[i];
                    if (NorthingExp[i] < p.minNorthing) p.minNorthing = NorthingExp[i];
                    if (EastingExp[i] > p.maxEasting) p.maxEasting = EastingExp[i];
                    if (EastingExp[i] < p.minEasting) p.minEasting = EastingExp[i];

                    p.Easting.Add(EastingExp[i]);  //replace original with expanded
                    p.Northing.Add(NorthingExp[i]);
                    double lat = 0.0;
                    double lon = 0.0;
                    utm.UTMtoLL(NorthingExp[i], EastingExp[i], p.UTMZone, ref lat, ref lon);
                    p.latitudeDeg.Add(lat);
                    p.longitudeDeg.Add(lon);

                    if (lat > p.maxLatDeg) p.maxLatDeg = lat;
                    if (lat < p.minLatDeg) p.minLatDeg = lat;
                    if (lon > p.maxLonDeg) p.maxLonDeg = lon;
                    if (lon < p.minLonDeg) p.minLonDeg = lon;
                }
                ////////////////////////////////////////////////////////////////////////////////////////////////////
                Constants.Log("Expanded the client polygon by 500m " + p.PolygonName);

                //we have modified a copy of the polygon -- new re-insert it into the list
                polygons[ipoly] = p;
            }
        }
コード例 #4
0
ファイル: polygonMath.cs プロジェクト: jekain314/KMLReader
        public void generateSmoothTrajectoryWithProNav(String DataSetFolder, String UTMZone, bool computeProjections, ref double maxBankDeg, 
            double ProNavGain, double deltaTime, double DistanceToTarget, double vehicleVelocity, double altitude, double swathWidth,
            List<double> NorthingIn, List<double> EastingIn, List<double> NorthingOut, List<double> EastingOut,
            List<double> NorthingProjected, List<double> EastingProjected, 
            List<double> NorthingIP1, List<double> EastingIP1, List<double> NorthingIP2, List<double> EastingIP2)
        {
            //////////////////////////////////////////////////////////////////////////////////////////
            //using an input set of path points generated by Google earth, create a smoothed
            //trajectory flyable by an aircraft that passes near the points.
            //////////////////////////////////////////////////////////////////////////////////////////

            //initialize the state at first vertex with heading along first segment
            double X = NorthingIn[0];
            double Y = EastingIn[0];
            //heading from 0th point towards the 1th point -- heading is positive CCW from north
            double heading = Math.Atan2(EastingIn[1] - EastingIn[0],
                                         NorthingIn[1] - NorthingIn[0]);

            //add the initial position to the output trajectory
            NorthingOut.Add(X);
            EastingOut.Add(Y);

            //stop a segment when the ProNav acceleration command results in a bank greater than some max bank threshold
            bool stopThisSegment = false;

            polygonMath polyMath = new polygonMath(EastingIn, NorthingIn, datasetFolder);
            UTM2Geodetic utm = new UTM2Geodetic();

            int lastXYVertex = 0;
            double distanceToNextVertex = 0;
            int iTime = 0;
            double bankCommand = 0.0;
            double maxBank = -999999.0;

            //integrate the state in the while loop
            while (!stopThisSegment)
            {
                //////////////////////////////
                //state:  X   Y   heading
                //////////////////////////////

                //get a point on the path that is orthognal to the velocity vector
                PointD pca = polyMath.pointOnPathOrthogonalToVelocityVector(heading, new PointD(X, Y),
                    ref lastXYVertex, ref distanceToNextVertex,
                    EastingIn, NorthingIn);

                //if (lastXYVertex == 1) break;

                //stopping condition -- have gone beyond last vertex in the path
                if (-distanceToNextVertex > 0)
                {
                    Console.WriteLine(" stopping on distanceToNextVertex " + distanceToNextVertex.ToString());
                    stopThisSegment = true;
                }

                //locate a point ahead of (X,Y) along the path by a prescribed distance
                //this becomes the target for pro nav guidance
                //placing the target farther ahead reduces the max bank but smooths the points
                PointD pAhead = polyMath.FuturePointOnLineFeature(
                    pca, lastXYVertex, distanceToNextVertex, DistanceToTarget,
                    EastingIn, NorthingIn);

                //X is north and Y is east
                double velX = vehicleVelocity * Math.Cos(heading);
                double velY = vehicleVelocity * Math.Sin(heading);

                //compute the Line-Of-Sight rate between the platform and the target point
                //the heading_dot will be commanded to -3*LOSRate per the ProNav
                // X -- North      Y -- East -- causes heading to be positive CCW rotation for Right Hand coordinate system
                double delX = pAhead.X - X;
                double delY = pAhead.Y - Y;
                double LOSAngle = Math.Atan2(delY, delX);
                double LOSRate = Math.Cos(LOSAngle) * Math.Cos(LOSAngle) * (-velY / delX + delY * velX / (delX * delX));

                X += velX * deltaTime;
                Y += velY * deltaTime;

                ////////////////////////////////////////////////////
                //generate the output file for the trajectory
                ////////////////////////////////////////////////////
                NorthingOut.Add(X);
                EastingOut.Add(Y);

                double accelCommand = ProNavGain * LOSRate * vehicleVelocity;  //units:  m/s/s

                //pursuit navigation
                //double accelCommand = -0.10 * (heading - LOSAngle) * vehicleVelocity;

                //bank command necessary to maintain level flight and achieve command lateral acceleration
                bankCommand = Math.Atan(accelCommand / Constants.Gravity);  // degrees
                if (Math.Abs(bankCommand) > maxBank) maxBank = Math.Abs(bankCommand);

                heading += (accelCommand / vehicleVelocity) * deltaTime;

                if (accelCommand / Constants.Gravity > 100.0)
                {
                    stopThisSegment = true;
                    Console.WriteLine(" stopping on the bank command threshold ");
                }

                if (iTime%3 == 0 && computeProjections)
                {
                    double Xproj = X + altitude * Math.Tan(bankCommand) * velY / vehicleVelocity;
                    double Yproj = Y - altitude * Math.Tan(bankCommand) * velX / vehicleVelocity;
                    NorthingProjected.Add(Xproj);
                    EastingProjected.Add(Yproj);

                    //creat endpoints for an image taken at this location
                    NorthingIP1.Add(Xproj +  swathWidth * velY / vehicleVelocity / 2.0 );
                    EastingIP1.Add( Yproj -  swathWidth * velX / vehicleVelocity / 2.0 );
                    NorthingIP2.Add(Xproj -  swathWidth * velY / vehicleVelocity / 2.0 );
                    EastingIP2.Add( Yproj +  swathWidth * velX / vehicleVelocity / 2.0 );

                    //predicted miss distance
                    //if we assume the future point doesnt move, we can compute the miss distance
                    //that would occur if the continue with pronav until the point-of-closest-approach
                    double tgo = DistanceToTarget / vehicleVelocity;
                    double Xmiss = 3.0 * (X + velX * tgo) / tgo * tgo;
                    double Ymiss = 3.0 * (Y + velY * tgo) / tgo * tgo;
                    //miss vector orthogonal to flight direction
                }

                iTime++;
                if (iTime > 5000)
                {
                    stopThisSegment = true;
                    Console.WriteLine("stopping on count");
                }

            } //end of trajectory generator
            maxBankDeg = maxBank*Constants.Rad2Deg;

            Console.WriteLine(" Max bank command = " + maxBankDeg.ToString("F2") + " deg");
        }
コード例 #5
0
ファイル: Form1.cs プロジェクト: jekain314/KMLReader
        List<LINEAR_FEATURE> linearFeatureCoverage(int numberParallelPaths, LINEAR_PATH_CENTERING centering,
            double altAGLMeters, double swathWidth, double vehicleVelocityMperSec)
        {
            /////////////////////////////////////////////////////////////////////////////////////////////////////
            //This procedure creates a mission plan from a kml linear path created by the Google Earth Path tool
            //The geodetic path points (vertices) must have been generated using "InspectKMLforMissions()"
            //In this procedure, the input path is "flown" using a 2D simulation and proportional navigation
            //Capability is provided to allow multiple side-by-side parallel paths
            //either centered over the inoput path of to the right of this path. Separate flight lines
            //may be required for a single path if the path turns are too sharp.
            /////////////////////////////////////////////////////////////////////////////////////////////////////

            //TODO:  get these from the input file
            //pronav numerical integration parameters
            double proNavGain       = 3.0;      //proportional Navigation Gain -- usually assumed to be 3.0
            double deltaTime        = 2.0;      //integration step size along the trajectory for the pro nav simulation
            double distanceToTarget = 2500.0;   //diatance ahead along the path the "rabbit" is placed

            double altitudeAGL = altAGLMeters;
            double vehicleVelocity  = vehicleVelocityMperSec;

            List<LINEAR_FEATURE> linearFeatures = new List<LINEAR_FEATURE>();

            //the following trajectories are constant for all parallel paths
            //these represent the smoothed trajectory for the input path
            //The parallel paths are parallel t the smoothed input path
            List<double>  EastingTrajectoryF = new List<double>();
            List<double>  NorthingTrajectoryF = new List<double>();
            List<double>  EastingTrajectoryB = new List<double>();
            List<double>  NorthingTrajectoryB = new List<double>();
            List<double>  EastingTrajectoryS = new List<double>();
            List<double>  NorthingTrajectoryS = new List<double>();

            List<double> placeHolder = new List<double>();

            //polyMat provides polygon and line path math tools
            polygonMath polyMath = new polygonMath(polys[0].Easting, polys[0].Northing, datasetFolder);

            String UTMZone = polys[0].UTMZone;

            double maxBankDeg = 0.0;

            //generate the pro nav smoothed forward trajectory
            polyMath.generateSmoothTrajectoryWithProNav(datasetFolder, UTMZone, false, ref maxBankDeg,
                proNavGain, deltaTime, distanceToTarget, vehicleVelocity, altitudeAGL, swathWidth,
                polys[0].Northing, polys[0].Easting, NorthingTrajectoryF, EastingTrajectoryF,
                placeHolder, placeHolder,
                placeHolder, placeHolder, placeHolder, placeHolder);

            //create a reversed set of path points so we can fly the path backwards
            List<double> NorthingB = new List<double>();
            List<double> EastingB = new List<double>();
            for (int i = polys[0].Northing.Count - 1; i >= 0; i--)
            {
                NorthingB.Add(polys[0].Northing[i]);
                EastingB.Add(polys[0].Easting[i]);
            }

            //generate the pro nav smoothed backward trajectory
            polyMath.generateSmoothTrajectoryWithProNav(datasetFolder, UTMZone, false, ref maxBankDeg,
                proNavGain, deltaTime, distanceToTarget, vehicleVelocity, altitudeAGL, swathWidth,
                NorthingB, EastingB, NorthingTrajectoryB, EastingTrajectoryB,
                placeHolder, placeHolder,
                placeHolder, placeHolder, placeHolder, placeHolder);

            List<double> NorthingOutBrev = new List<double>();
            List<double> EastingOutBrev = new List<double>();
            //reverse this trajectory so we can match it to the forward trajectory
            for (int i = NorthingTrajectoryB.Count - 1; i >= 0; i--)
            {
                NorthingOutBrev.Add(NorthingTrajectoryB[i]);
                EastingOutBrev.Add(EastingTrajectoryB[i]);
            }

            //
            //average the two paths to get a smoothed path that can be flown both ways
            int numRecs = NorthingTrajectoryF.Count;
            double distanceToNextVertex = 0;
            int index = 0;
            if (NorthingTrajectoryF.Count > NorthingTrajectoryB.Count)
                numRecs = NorthingTrajectoryB.Count;
            //go through all points and do the averaging
            for (int i = 0; i < numRecs; i++)
            {
                //increment through points in forward trajectory
                //locate point-of-closest-approach on the backward trajectorty
                //average these two points to get the smoothed trajectory

                PointD pca = polyMath.distanceFromPoint2Linefeature(
                    new PointD(NorthingTrajectoryF[i], EastingTrajectoryF[i]),
                    ref index, ref distanceToNextVertex, NorthingOutBrev, EastingOutBrev);

                NorthingTrajectoryS.Add((NorthingTrajectoryF[i] + pca.X) / 2.0);
                EastingTrajectoryS.Add((EastingTrajectoryF[i] + pca.Y) / 2.0);

            }

            /*
            //the following diagnostic kml files are constant for each path
            prepareKmlForUTMPointList(datasetFolder, "TrajectoryF",
                NorthingTrajectoryF, EastingTrajectoryF, UTMZone);
            prepareKmlForUTMPointList(datasetFolder, "TrajectoryB",
                NorthingTrajectoryB, EastingTrajectoryB, UTMZone);
            prepareKmlForUTMPointList(datasetFolder, "TrajectoryS ",
                NorthingTrajectoryS, EastingTrajectoryS, UTMZone);
             * */

            //prepare the trajectory information for the offset parallel paths
            //NOTE: path 0 is always assumed to be the initial path flown from start-to-end as defined by the input data
            //      successive even paths are flown end-to-start (reversed direction)
            //      successive odd paths are flown start-to-end
            for (int iPar = 0; iPar < numberParallelPaths; iPar++)
            {
                LINEAR_FEATURE linearFeature = new LINEAR_FEATURE();

                linearFeature.proNavGain = proNavGain;
                linearFeature.rabbitAheadDistance = distanceToTarget;

                linearFeature.EastingProNavS        = new List<double>();
                linearFeature.NorthingProNavS       = new List<double>();
                linearFeature.EastingProjection     = new List<double>();
                linearFeature.NorthingProjection    = new List<double>();
                linearFeature.EastingImage1         = new List<double>();
                linearFeature.NorthingImage1        = new List<double>();
                linearFeature.EastingImage2         = new List<double>();
                linearFeature.NorthingImage2        = new List<double>();
                linearFeature.alongPathAltitude     = new List<double>();

                //this where we offset the input path depending on  numberParallelPaths & LINEAR_PATH_CENTERING
                //generate an offset trajectory to the smoothed trajectory
                polygonMath polyMath2 = new polygonMath(EastingTrajectoryS, NorthingTrajectoryS, datasetFolder);
                double offset = 0.0;
                if (     centering == LINEAR_PATH_CENTERING.centeredOnInputPath) offset = -(numberParallelPaths - 1) * swathWidth / 2.0 + iPar * swathWidth;
                else if (centering == LINEAR_PATH_CENTERING.offsetToLeftOfInputPath) offset = iPar * swathWidth;
                else if (centering == LINEAR_PATH_CENTERING.offsetToRightOfInputPath) offset = -iPar * swathWidth;
                offset *= 0.70; ///this accounts for a 30% sidelap between paths

                //create the current path when multiple paths are requested
                List<double> EastingParallel = new List<double>();
                List<double> NorthingParallel = new List<double>();
                //return a parallel path from the input smoothed path
                polyMath2.parallelPath(ref EastingParallel, ref NorthingParallel, offset);

                //should this be polyMath2 ???
                linearFeature.pathLength = polyMath.pathLength();

                //create a reversed set of path points so we can fly the path backwards
                List<double> NorthingRev = new List<double>();
                List<double> EastingRev = new List<double>();
                if (iPar % 2 != 0)  //locate the odd paths (1, 3, 5, 7 ...
                {
                    for (int i = EastingTrajectoryS.Count - 1; i >= 0; i--)
                    {
                        NorthingRev.Add(NorthingParallel[i]);
                        EastingRev.Add(EastingParallel[i]);
                    }
                    for (int i = 0; i < EastingTrajectoryS.Count; i++)
                    {
                        NorthingParallel[i] = NorthingRev[i];
                        EastingParallel[i] = EastingRev[i];
                    }
                }

                //generate the pro nav solution for the smoothed forward/backward trajectory
                //this is the trajectory that is expected from the actual flight mission
                polyMath.generateSmoothTrajectoryWithProNav(datasetFolder, UTMZone, true, ref maxBankDeg,
                    proNavGain, deltaTime, distanceToTarget/2.0, vehicleVelocity, altitudeAGL, swathWidth,
                    NorthingParallel, EastingParallel,
                    linearFeature.NorthingProNavS,     linearFeature.EastingProNavS,

                    linearFeature.NorthingProjection, linearFeature.EastingProjection,
                    linearFeature.NorthingImage1, linearFeature.EastingImage1,
                    linearFeature.NorthingImage2, linearFeature.EastingImage2);

                String parallelPathNotation= "";
                if (numberParallelPaths > 0) parallelPathNotation = iPar.ToString("D2");

                /*
                //the following kml output files vary with each parallel path
                prepareKmlForUTMPointList(datasetFolder, "ParallelPath" + parallelPathNotation,
                    NorthingParallel, EastingParallel, UTMZone);
                prepareKmlForUTMPointList(datasetFolder, "ProNavS" + parallelPathNotation,
                    linearFeature.NorthingProNavS, linearFeature.EastingProNavS, UTMZone);
                prepareKmlForUTMPointList(datasetFolder, "Projection" + parallelPathNotation,
                    linearFeature.NorthingProjection, linearFeature.EastingProjection, UTMZone);
                prepareKmlForUTMPointPairs(datasetFolder, "ImageEndpoints" + parallelPathNotation, UTMZone,
                        linearFeature.NorthingImage1, linearFeature.EastingImage1,
                        linearFeature.NorthingImage2, linearFeature.EastingImage2);
                 * */

                linearFeature.maximumMeasuredBank = maxBankDeg;

                //add the linear feature just prepared fo the list of linear features
                //there will be one prepared linear feature for each of the parallel paths
                linearFeatures.Add(linearFeature);
            }

            //return the list of linear features prepared in this routine.
            return linearFeatures;
        }
コード例 #6
0
ファイル: Form1.cs プロジェクト: jekain314/KMLReader
        private COVERAGE_SUMMARY getPolygonFlightPathCoverage(double rotationRad,
            Polygon p, double swathWidthKm, double maxFLLengthKm, double minLineLength, double DRImageHeightKm,
            ref int numSets, ref int numFlightLines, ref double[,,] XAllSets, ref double[,,] YAllSets)
        {
            /////////////////////////////////////////////////////////////////////////
            //this procedure defines a set of flight lines that cover a polygon
            //The flight lines are returned on the arrays XallSets, YAllSets
            /////////////////////////////////////////////////////////////////////////

            /////////////////////////////////////////////////////////////////////////////////////////////////////////
            //For coverages other than North-South,
            //rotate the input easting, Northing polygon vertices by angle about the polygon centroid
            //cover the rotated polygon with a North-South set of flight lines
            //This will result in a YAllSets[i,k,j], XAllsets[i,k,j] set of flight line endpoints
            //where i=0,1 to represent the start or end
            //      j= the set number
            //      k= flightline number within the set
            //now rotate the flight line endpoints by -theta about the polygon centroid.
            //now YAllSets, XAlSets are rotated vectors
            //go through the set-based flight lines, tossing zero-length lines
            //and to produce a 1D (non-set-based) list of flight lines
            //The flightline-length computation must use the generalized UTM flight line endpoints.
            //////////////////////////////////////////////////////////////////////////////////////////////////////////

            //
            //rotate the input polygon
            List<double> originalPolygonEasting = new List<double>();
            List<double> originalPolygonNorthing = new List<double>();
            for (int i = 0; i < p.Northing.Count; i++)
            {
                originalPolygonNorthing.Add(p.Northing[i]);
                originalPolygonEasting.Add(p.Easting[i]);
            }
            //rotate the original coordinates
            p.maxEasting = -999999999999.0; p.maxNorthing = -9999999999999.0;
            p.minEasting = 999999999999.0; p.minNorthing = 9999999999999.0;

            //double rotation = (-p.rotationAngleDeg) * Constants.Deg2Rad;

            for (int i = 0; i < p.Northing.Count; i++)
            {
                double delEasting = originalPolygonEasting[i] - p.meanEasting;
                double delNorthing = originalPolygonNorthing[i] - p.meanNorthing;
                p.Easting[i]  = p.meanEasting  + Math.Cos(rotationRad) * delEasting + Math.Sin(rotationRad) * delNorthing;
                p.Northing[i] = p.meanNorthing - Math.Sin(rotationRad) * delEasting + Math.Cos(rotationRad) * delNorthing;

                //recompute the maximums for the rotated vertices
                if (p.Easting[i] > p.maxEasting) p.maxEasting = p.Easting[i];
                if (p.Northing[i] > p.maxNorthing) p.maxNorthing = p.Northing[i];
                if (p.Easting[i] < p.minEasting) p.minEasting = p.Easting[i];
                if (p.Northing[i] < p.minNorthing) p.minNorthing = p.Northing[i];
            }
            //compute the north-to-south distance wherein we will space the flightlines
            double NSDstanceKm = (p.maxNorthing - p.minNorthing) / 1000.0;
            double EWDstanceKm = (p.maxEasting - p.minEasting) / 1000.0;
            double NSDstanceMi = (p.maxNorthing - p.minNorthing) / 0.3048 / 5280.0;
            double EWDstanceMi = (p.maxEasting - p.minEasting) / 0.3048 / 5280.0;
            //must also recompute the maxNorthing and maxEasting for the rotated vertices

            //int numFlightLines = 0, numSets = 0;
            double maxFLLengthMet = 0.0;
            double E2WKm = 0.0;

            numFlightLines = Convert.ToInt32(Math.Floor(EWDstanceKm / swathWidthKm));  //flight lines should always be inside the polygon

            //input flight line length is reduced to cause an integer number of equal-length flight lines to span the NS extent
            numSets = Convert.ToInt32(Math.Floor(NSDstanceKm / maxFLLengthKm)) + 1;
            maxFLLengthKm = NSDstanceKm / numSets;  //make maxFLLength equal-to or smaller-than max so each set has constant NS length
            double maxFLLengthMi = maxFLLengthKm * 1000.0 / 0.3048 / 5280.0;
            maxFLLengthMet = maxFLLengthKm * 1000.0;
            E2WKm = swathWidthKm * numFlightLines;  //redefine the E2W coverage distance so that flightline spacing fixed by camera FOV and sidelap

            //this is the final UTM set of flight line endpointd
            //XAllSets[k,i,j], YAllSets[k,i,j] whete k=0,1 (start,end of flight line), i=Set, j=FlightlineInSet
            //X is the Easting and Y is the Northing
            //the Start is always below (to the south) from the end for a flight line
            //double[, ,] XAllSets;
            //double[, ,] YAllSets;

            //set up for the polygon math
            polygonMath polyMath = new polygonMath(p.Easting, p.Northing, datasetFolder);

            //these arrays store the endpoints of the flight lines not-terminated by max line length constraint
            double[,] XintAllFL = new double[2, numFlightLines + 1];  //beginning and end of each flight line
            double[,] YintAllFL = new double[2, numFlightLines + 1];

            double EastingStart = 0, EastingEnd = 0, NorthingStart = 0, NorthingEnd = 0;
            //set the first NS flight line on the eastmost side -- no more than 1/2 swathwidth inside the polygon
            //because the flight lines are N-S, the eastings for the endpoints will be the same
            //NOTE:  EWDstanceKm is the max extent of the polygon rectangular boundary
            //E2WKm will be <= EWDstanceKm
            EastingStart = p.minEasting + 1000.0 * (EWDstanceKm - E2WKm) / 2.0; //fight lines will always be inside the polygon
            EastingEnd = EastingStart; // all NS flight lines have the same EW coordinates (they are exactly NS)
            //initialize the initial flight line ends as the max of the polygon rectangular envelope
            NorthingStart = p.maxNorthing;
            NorthingEnd = p.minNorthing;

            outfile.WriteLine();
            outfile.WriteLine(" Precompute the flight line lengths without maxLength consideration");

            /////////////////////////////////////////////////////////////////////////////////////////////////////
            //without the below statement, the last flight line will be too far inside the right max extent
            //something fishy about the above integer math!!!!!
            /////////////////////////////////////////////////////////////////////////////////////////////////////
            numFlightLines++;

            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //pre compute all the flightline intersections with the polygon without consideration of Sets that will act to reduce the flight line length
            //this initial step computes the flightlines as though they can have infinite length
            //  Sets:  vertically divide the Project polygon into equal-distance regions where we will look for non-zero flight lines
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            double maxUnterminatedLineLength = -999.0;
            for (int i = 0; i < numFlightLines; i++)
            {
                //flight line intersections wthout consideration of line length
                double[] Xint = new double[2];
                double[] Yint = new double[2];

                //compute the north-most and south-most flightline ends by the intersection of the flightline with the polygon
                //here we only return two intersections -- internal to this procedure, we compute the most-north and most-south of all intersections
                //note the polygons may contain concave areas that would cause more than two intersections
                int intersectionCounter =
                    polyMath.intersectionOfLineWithPolygon(EastingStart, NorthingStart, EastingEnd, NorthingEnd, ref Xint, ref Yint);

                XintAllFL[0, i] = Xint[0];  //west-most line intersection with poly for Flightline i
                XintAllFL[1, i] = Xint[1];  //east-most line intersection with poly
                YintAllFL[0, i] = Yint[0];  //south-most line intersection with poly
                YintAllFL[1, i] = Yint[1];  //north-most line intersection with poly

                double lineLength = 0.0;
                lineLength = (YintAllFL[1, i] - YintAllFL[0, i]);

                outfile.WriteLine(String.Format("line number: {0,2}  non-terminated linelength = {1,12:#.00} (km) {2,12:#.00} (Mi)",
                    i, lineLength / 1000.0, lineLength / 0.3048 / 5280.0));
                outfile.Flush();

                //
                if (lineLength > maxUnterminatedLineLength) maxUnterminatedLineLength = lineLength;

                //increment the NS flight line by the swath width -- assume North-South flightline that moves to the east
                EastingStart += (swathWidthKm * 1000.0);
                EastingEnd = EastingStart;
            }

            /////////////////////////////////////////////////////////////////////////////////////////////////////
            //completed locating the coverage flight lines without consideration of maximum flight line length
            /////////////////////////////////////////////////////////////////////////////////////////////////////

            outfile.WriteLine();
            outfile.WriteLine();
            //input flight line length is reduced to cause an integer number of equal-length flight lines to span the NS extent
            outfile.WriteLine(" Break up the non-terminated lines using the adjusted flightline maxLength: " + maxFLLengthMi.ToString("F2") + "  (mi)");
            outfile.WriteLine(" Number of Sets: " + numSets.ToString());
            outfile.WriteLine();
            outfile.WriteLine();
            outfile.Flush();

            //these will hold the flight line endpoints that are broken into sets to reduce flight line length
            XAllSets = new double[2, numSets, numFlightLines + 1];
            YAllSets = new double[2, numSets, numFlightLines + 1];

            /////////////////////////////////////////////////////////////
            //takes care of the case when there is only a single set
            /////////////////////////////////////////////////////////////
            //handle the case where the non-terminated line length is less than the client-requested max line length
            //if (maxUnterminatedLineLength < maxFLLengthMet) numSets = 1;
            for (int i = 0; i < numSets; i++) for (int j = 0; j < numFlightLines; j++) for (int k = 0; k < 2; k++)
                    {
                        XAllSets[k, i, j] = XintAllFL[k, j];
                        YAllSets[k, i, j] = YintAllFL[k, j];
                    }

            FLSum = new FlightlineSummary[numSets * numFlightLines + 1];

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //now break up the non-terminated (too long) NS flight lines into the subsets defined by the user-set max flight line length
            // the subset regions will have equal vertical (NS) height if lines end at a set boundary
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            //cycle through the number of sets as determined by the max flight line length
            for (int i = 0; i < numSets; i++)  //numsets breaks the too-long flight lines to be less than the max flight line
            {
                outfile.WriteLine();
                outfile.WriteLine("      Set: " + i.ToString());
                outfile.WriteLine();
                //define flight line candidate endpoints based on only the set start points
                //these are adjusted based on line-end intersections with the client polygon
                double startSetY = 0, endSetY = 0, startSetX = 0, endSetX = 0;
                //define the vertical locations of the Set endpoints -- starts at the north-most set and moves south
                startSetY = p.maxNorthing - i * maxFLLengthKm * 1000.0;     //test subset flight line Ystart at the Set start
                endSetY = startSetY - maxFLLengthKm * 1000.0;         //test subset flight line Yend at the Set end

                //cycle through the number of flight lines spaced across the plan pattern for each along-line set
                for (int j = 0; j < numFlightLines; j++)
                {
                    //start & end X (easting) values are equal and increment to the east with flight line counter
                    startSetX = p.minEasting + 1000.0 * (EWDstanceKm - E2WKm) / 2.0 + j * swathWidthKm * 1000.0;
                    //EW coordinates of NS flightlines are identical
                    endSetX = startSetX;

                    //at this point we have a set of flight lines defined by the along-line set and across-line FL spacing
                    //based solely on a rectangular region defined by the max/min coverage boundaries
                    //we need to terminate these lines based on their intersections with the client polygon

                    //the below arrays are the intersections of the flight line with the client polygon
                    double[] Xint = new double[2];
                    double[] Yint = new double[2];

                    //compute the number of intersections of the per-set line segment with the client polygon
                    //this can be zero, 1, 2, ....
                    int numIntersects = polyMath.intersectionOfLineWithPolygon(startSetX, startSetY, endSetX, endSetY, ref Xint, ref Yint);

                    //test to see if both ends of the test flight line are outside the total Project polygon external hull -- if so skip remainder of this loop --
                    //NOTE: endSetY will always be to the North of startSetY -- End and Start have a geographic order
                    //endsetY is south of startSetY  -- YintAllFL[1, j] is south of YintAllFL[0, j]
                    //YintAllFL[0, i] south-most line intersection with poly
                    //YintAllFL[1, i] north-most line intersection with poly
                    if (endSetY > YintAllFL[1, j] || startSetY < YintAllFL[0, j])
                    {
                        outfile.WriteLine("both ends of FL= " + j.ToString() + " outside set " + i.ToString());
                        //force this line length for this set to zero -- else it will be counted again on another set
                        YAllSets[1, i, j] = YintAllFL[0, j];
                        YAllSets[0, i, j] = YintAllFL[0, j];
                        continue;
                    }

                    //if we get here -- at least one line end is inside the current set boundary extent
                    //  numIntersects is the number of intersections of the set-terminated flight line with the client polygon
                    //there can be zero intersects even with both ends outside or inside the polygon
                    if (numIntersects == 0)
                    {
                        //test to see if one end is inside the polygon  -- since there are zero intersects, this is the case where both ends are inside the polygon
                        if (polyMath.pointInsidePolygon(p.Easting.Count, endSetX, endSetY, p.Easting, p.Northing)) //both endpoints are inside the polygon
                        {
                            // set the desired flight line ends to fall on the set boundaries
                            YAllSets[1, i, j] = startSetY;
                            YAllSets[0, i, j] = endSetY;
                            outfile.WriteLine(" both line ends are inside the client poly ");
                        }
                        //the below "continue" is redundant with the first test above -- should never get here
                        //there are zero set-line intersections and neither end is inside the client poly
                        else
                        {
                            outfile.WriteLine("set line has at least one intersections with client poly -- but neither end is inside the poly");
                            continue; //this is the case where the poly is concave so that the complete terminated line is outside the polygon
                        }
                    }
                    else if (numIntersects % 2 == 1) //one of the set-boundary-terminated flight lines is outside the client polygon
                    {
                        outfile.WriteLine(" one line end is inside the client poly ");
                        //test to see if the endpoint is inside the client polygon
                        //if so, then this end is on the desired flight line
                        //the other end is at the set boundary
                        if (polyMath.pointInsidePolygon(p.Easting.Count, endSetX, endSetY, p.Easting, p.Northing))
                        {
                            YAllSets[1, i, j] = Yint[1];
                            YAllSets[0, i, j] = endSetY;
                        }
                        else //the startpoint is inside the client polygon
                        {
                            YAllSets[1, i, j] = startSetY;
                            YAllSets[0, i, j] = Yint[0];
                        }
                    }
                    //here we have an even number of intersctions
                    else //either both of the unterminated lines are outside the polygon or there is a concave polygon section
                    // must also consider a jut-out where both ends are outside ---
                    {
                        if (!polyMath.pointInsidePolygon(p.Easting.Count, endSetX, endSetY, p.Easting, p.Northing))
                        {
                            outfile.WriteLine("even number of intersections -- both ends are outside the client poly ");
                            //both ends must be outside the polygon
                            YAllSets[1, i, j] = Yint[1];
                            YAllSets[0, i, j] = Yint[0];
                        }
                        else //both ends must be inside the polygon
                        {
                            outfile.WriteLine("even number of intersections --  both ends are inside the client poly ");
                            YAllSets[1, i, j] = startSetY;
                            YAllSets[0, i, j] = endSetY;
                        }
                    }

                    double lineLengthKm = 0, lineLengthMi = 0;
                    //this becomes a list of the flight lines on a Set grouping that cover the polygon
                    //need to keep the order of the line within the set ... e.g., track those on the ends
                    XAllSets[0, i, j] = startSetX;    //start of the line  (this is to the South for a NS flightline)
                    XAllSets[1, i, j] = endSetX;      //end of the line

                    lineLengthKm = (YAllSets[1, i, j] - YAllSets[0, i, j]) / 1000.0;
                    lineLengthMi = (YAllSets[1, i, j] - YAllSets[0, i, j]) / 0.3048 / 5280.0;

                    outfile.WriteLine(String.Format("lines terminated at Set boundaries: set= {0,2} FL= {1,2} length: {2,10:#.00} Km {3,10:#.00} Mi  intersects = {4}",
                        i, j, lineLengthKm, lineLengthMi, numIntersects));
                    outfile.Flush();

                    //below we do the following:
                    //if a line is too short, add the segment to either the next or last extension of the line
                    //if the short line is at the bottom of this Set, add to the top of the next set
                    //if the short line is at the top of this Set, add to the bottom of the last set

                }
            }

            outfile.WriteLine();
            outfile.WriteLine();
            outfile.WriteLine("Extend the flight lines slightly to account for the descretization resulting from the swath width");

            ///////////////////////////////////////////////////////////////////////////////////////////
            //we have a set of flight lines that cover the polygon spaced per the swath width
            //However, if we use these flight lines, we will end up with gaps at the polygon edges
            //due to the discretization of the flight lines. A short flight line prior to a
            //longer flight line must be extended so that its edge covers the polygon.
            //this should really be done by locating the polygon intersections at the halfway points between
            //each of the flightline. We use the 0.75 below to account for this approximation.
            //if the polygon edges were linear between the endpoints, we would use 0.5
            //if the edge bewteen the endpoint has a vertices with convex shape it should be bigger than 0.5
            //////////////////////////////////////////////////////////////////////////////////////////

            //save the old endpoints
            double[, ,] YAllSetsTemp = new double[2, numSets, numFlightLines];
            for (int i = 0; i < numSets; i++) for (int j = 0; j < numFlightLines; j++) for (int k = 0; k < 2; k++) YAllSetsTemp[k, i, j] = YAllSets[k, i, j];
            double[, ,] XAllSetsTemp = new double[2, numSets, numFlightLines];
            for (int i = 0; i < numSets; i++) for (int j = 0; j < numFlightLines; j++) for (int k = 0; k < 2; k++) XAllSetsTemp[k, i, j] = XAllSets[k, i, j];

            for (int i = 0; i < numSets; i++)
            {
                for (int j = 0; j < numFlightLines; j++)
                {
                    double lineLengthKm = lineLengthKm = (YAllSets[1, i, j] - YAllSets[0, i, j]) / 1000.0;
                    //discard zero-length lines
                    if (lineLengthKm == 0.0)
                    {
                        outfile.WriteLine(" discard set {0} FL {1} due to zero length", i, j);
                        continue;
                    }
                    else
                    {
                        outfile.WriteLine(" keep set {0,2} FL {1,2} length = {2,8:#.00} (km) {3,8:#.00} (mi) ", i, j, lineLengthKm, lineLengthKm * 1000.0 / 0.3048 / 5280.0);
                    }

                    if (j < (numFlightLines - 2))
                    {
                        double lineLengthKm2 = 0;
                        lineLengthKm2 = (YAllSetsTemp[1, i, j + 1] - YAllSetsTemp[0, i, j + 1]) / 1000.0;

                        if (lineLengthKm2 == 0.0) continue;
                        //test to see if the next flight line end is above the current flight line end
                        //if so, then extend this flight line halfway to the next line end
                        if (YAllSetsTemp[1, i, j] < YAllSetsTemp[1, i, j + 1]) YAllSets[1, i, j] += 0.75 * (YAllSetsTemp[1, i, j + 1] - YAllSets[1, i, j]);
                        //test to see if the next flight line start is below the current flight line start
                        //if so, then extend this flight line start point halfway to the next line startpoint
                        if (YAllSetsTemp[0, i, j] > YAllSetsTemp[0, i, j + 1]) YAllSets[0, i, j] -= 0.75 * (YAllSetsTemp[0, i, j] - YAllSetsTemp[0, i, j + 1]);
                    }

                    if (j > 0)
                    {
                        double lineLengthKm2 = lineLengthKm2 = (YAllSetsTemp[1, i, j - 1] - YAllSetsTemp[0, i, j - 1]) / 1000.0;
                        if (lineLengthKm2 == 0.0) continue;

                        //test to see if the prior flight line end is above the current flight line end
                        //if so, then extend this flight line end point halfway to the prior line end point
                        if (YAllSetsTemp[1, i, j] < YAllSetsTemp[1, i, j - 1]) YAllSets[1, i, j] += 0.75 * (YAllSetsTemp[1, i, j - 1] - YAllSetsTemp[1, i, j]);

                        //test to see if the prior flight line start is below the current flight line start
                        //if so, then extend this flight line start point halfway to the prior line start point
                        if (YAllSetsTemp[0, i, j] > YAllSetsTemp[0, i, j - 1]) YAllSets[0, i, j] -= 0.75 * (YAllSetsTemp[0, i, j] - YAllSetsTemp[0, i, j - 1]);
                    }
                }
            }

            //output a summary of the above computations
            for (int i = 0; i < numSets; i++)
            {
                outfile.WriteLine("Set = " + i.ToString("D2"));
                for (int j = 0; j < numFlightLines; j++)
                {
                    double newlineLengthKm = (YAllSets[1, i, j] - YAllSets[0, i, j]) / 1000.0;
                    double oldlineLengthKm = (YAllSetsTemp[1, i, j] - YAllSetsTemp[0, i, j]) / 1000.0;
                    outfile.WriteLine("FL = {0,2}  oldLength = {1,8:#.00} (km)   newLength = {2,8:#.00} ", j, oldlineLengthKm, newlineLengthKm);
                }
            }

            outfile.WriteLine();
            outfile.WriteLine();
            outfile.WriteLine("Go back through the terminated flight lines and add too short lines to prior set ");
            outfile.Flush();

            //////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //go back through the flight line segments, ordered by set & flightline, and cull the "zero-length" segments
            //also add the too-short segments to the adjoining (to the South) Set
            //Caveat:  adding the too-short segments to the South Set can result in some odd outlier flightline groupings!!!
            //Resolution: at the start of a set: once we "keep" a segment, dont adjoin anymore short lines to the south
            //            but at the end of a Set, once we adjoin a segment, must also adjoin the remainder
            //  thus we have to look for short flightlines going forward -- terminating after we find a sufficiently long line
            //  and then go backward, again stopping after  we have found a sufficiently long line
            //////////////////////////////////////////////////////////////////////////////////////////////////////////////
            int numTooShortLines = 0;
            for (int i = 0; i < numSets - 2; i++)   //TEMPORARY ???
            {
                //define the vertical locations of the Set endpoints
                double startSetY = p.maxNorthing - i * maxFLLengthKm * 1000.0; //test subset flight line Ystart at the Set start
                double endSetY = startSetY - maxFLLengthKm * 1000.0;           //test subset flight line Yend at the Set end

                int jStart = 0, jEnd = numFlightLines, jDelta = 1;  //conditions that cause going forward for each set
                for (int k = 0; k < 2; k++)   //causes going backward and forward through the flightlines in a Set -- see above Caveat.
                {
                    if (k == 1)  //going backward -- lines go from largest to smallest
                    { jStart = numFlightLines - 1; jEnd = 0; jDelta = -1; }  //conditions that cause going backward

                    //multiplying by "-1" on the back pass flips the equality!! -- so start at the end going down to "0" (j>-1)
                    for (int j = jStart; (jDelta * j) < (jDelta * jEnd - 1); j += jDelta)
                    {
                        //test to see if both ends of the test flight line are outside the polygon -- if so skip remainder of this loop --
                        if (endSetY > YintAllFL[1, j] || startSetY < YintAllFL[0, j]) continue;

                        double lineLengthKm = (YAllSets[1, i, j] - YAllSets[0, i, j]) / 1000.0;
                        double lineLengthMi = (YAllSets[1, i, j] - YAllSets[0, i, j]) / 0.3048 / 5280.0;

                        outfile.WriteLine(String.Format("set {0} FL {1} linelength = {2,15:#.00} Km {3,15:#.00} Mi", i, j, lineLengthKm, lineLengthMi));
                        outfile.Flush();

                        if (lineLengthKm == 0) continue;
                        //if zero length -- continue
                        //if a line is too short, add the segment to either the next or last extension of the line

                        if (lineLengthKm < minLineLength)
                        {
                            numTooShortLines++;
                            //if the short line is at the bottom of this Set, add to the top of the next set
                            if (YAllSets[0, i, j] == endSetY && i < (numSets - 1)) //bottom of this short line is at the bottom of the Set
                            {
                                outfile.WriteLine(String.Format("remove and add to top of next set:: {0} {1} {2,15:#.00} Km", i, j, lineLengthKm));
                                outfile.Flush();
                                YAllSets[1, i + 1, j] += lineLengthKm * 1000.0; //bottom this segment added to top of next segment
                                YAllSets[0, i, j] = 0;  //set old short segment to zero
                                YAllSets[1, i, j] = 0;  //set old short segment to zero
                            }

                            //if the short line is at the top of this Set, add to the bottom of the last set
                            else if (YAllSets[1, i, j] == startSetY && i > 0) ////top of this short line is at the top of the Set
                            {
                                outfile.WriteLine(String.Format("remove and add to bottom of last set:: {0} {1} {2,15:#.00} Km", i, j, lineLengthKm));
                                outfile.Flush();
                                YAllSets[0, i - 1, j] -= lineLengthKm * 1000.0; //top this segment added to bottom of last segment
                                YAllSets[0, i, j] = 0;  //set old short segment to zero
                                YAllSets[1, i, j] = 0;  //set old short segment to zero
                            }
                            else
                            {
                                //if both ends of the short line are on the polygon, then do nothing.
                                if (k == 0) outfile.WriteLine(String.Format("forward  Pass: short line contained within the polygon:: {0} {1} {2,15:#.00} Km", i, j, lineLengthKm));
                                if (k == 1) outfile.WriteLine(String.Format("backward Pass: short line contained within the polygon:: {0} {1} {2,15:#.00} Km", i, j, lineLengthKm));
                                outfile.Flush();
                            }

                        }
                        //below break causes the short flight lies to be merged with the Southern set either at the start or end of a Set
                        else break;  //this breaks after we have found the first occurrence of a sufficient long fliight line
                    }
                }  //end of the k-look --- k=0 is forward and k=1 is backward
            }
            outfile.WriteLine("Number of moved too-short flight lines = {0,2}", numTooShortLines);

            /////////////////////////////////////////////////////////////////////////////////////////
            //adjust the photocenters so that they fall on a rectangular grid
            //grid origin is always the NW corner of the bounding rectangle
            //note that the rotated flight lines are still North-South
            //make adjustments to the UTM north and south flight line endpoints
            ///////////////////////////////////////////////////////////////////////////////

            outfile.WriteLine();
            outfile.WriteLine("Adjust the flight line endoints so they fall on a rectangular grid");
            COVERAGE_SUMMARY covSummary = new COVERAGE_SUMMARY();
            covSummary.numTotalFlightLines = 0;
            covSummary.totalFlightLineLength = 0.0;

            for (int i = 0; i < numSets; i++)
            {
                outfile.WriteLine("Set= {0,2} ", i);
                for (int j = 0; j < numFlightLines; j++)
                {
                    double distanceBetweenTriggersMeters = DRImageHeightKm * 1000.0;
                    double originalFLlength = YAllSets[1, i, j] - YAllSets[0, i, j];
                    //make FL start  fall on a grid with downrange spacing of distanceBetweenTriggers
                    //the start end is always below the end (to the south for a NS flightline)
                    //compute the number of grid cells from the origin -- the "+1" ensures it covers (is above) the non-gridded flight line
                    int numGridsFromMaxNorthingS = (int)((p.maxNorthing - YAllSets[0, i, j]) / distanceBetweenTriggersMeters);
                    //the "+1" below always ensures the quantized start points are outside (below) the polygon.
                    //this will result in a single frame duplication between sets.
                    YAllSets[0, i, j] = p.maxNorthing - (numGridsFromMaxNorthingS + 1) * distanceBetweenTriggersMeters;

                    //make FL end latitude fall on a grid with downrange spacing of distanceBetweenTriggers
                    //compute the number of grid cells from the origin -- the "-1" ensures it covers the non-gridded flight line
                    int numGridsFromMaxNorthingE = (int)((p.maxNorthing - YAllSets[1, i, j]) / distanceBetweenTriggersMeters) + 1;
                    //the "-1" below always ensures the quantized endponts points are outside (above) the polygon (note the double negative.
                    //this will result in a songle frame duplication between sets.
                    YAllSets[1, i, j] = p.maxNorthing - (numGridsFromMaxNorthingE - 1) * distanceBetweenTriggersMeters;
                    double finalFLlength = YAllSets[1, i, j] - YAllSets[0, i, j];
                    outfile.WriteLine("FL = {0,2}  original length = {1,8:#.00} (km)  adjusted length = {2,8:#.00} ",
                        j, originalFLlength, finalFLlength);
                    if (finalFLlength > 0)
                    {
                        covSummary.numTotalFlightLines++;
                        covSummary.totalFlightLineLength += finalFLlength;
                    }
                }
            }
            covSummary.totalFlightLineLength /= 1000.0;
            covSummary.averageFlightLineLength = covSummary.totalFlightLineLength / covSummary.numTotalFlightLines;

            /////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //all the above was performed assuming the input polygon was rotated to a North-South orientation
            //NS flightlines were computer to cover the polygon
            //we must now counter-rotate the resulting flight lines back to their original geometry
            //this approach preseves the flightline relationship with the original polygon
            //The resulting flight lines are now arbitrarily rotated relative to north
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////

            //retrieve the original non-rotated UTM input coordinates
            for (int i = 0; i < p.Northing.Count; i++)
            {
                p.Easting[i] = originalPolygonEasting[i];
                p.Northing[i] = originalPolygonNorthing[i];
            }

            //rotate the flight line endpoints back to the original non-rotated coordinate frame
            //X corresponds to Eastng, Y to Northing --
            //note that in the initial rotation, the variable "rotation" was set to p.rotationDeg
            //below we rotation with -rotation to get back to the original coordinates
            for (int i = 0; i < numSets; i++)
            {
                for (int j = 0; j < numFlightLines; j++)
                {
                    for (int k = 0; k < 2; k++)
                    {
                        double delEasting = XAllSets[k, i, j] - p.meanEasting;
                        double delNorthing = YAllSets[k, i, j] - p.meanNorthing;
                        XAllSets[k, i, j] = p.meanEasting  + Math.Cos(-rotationRad) * delEasting + Math.Sin(-rotationRad) * delNorthing;
                        YAllSets[k, i, j] = p.meanNorthing - Math.Sin(-rotationRad) * delEasting + Math.Cos(-rotationRad) * delNorthing;
                        XAllSets[k, i, j] = p.meanEasting  + Math.Cos(-rotationRad) * delEasting + Math.Sin(-rotationRad) * delNorthing;
                        YAllSets[k, i, j] = p.meanNorthing - Math.Sin(-rotationRad) * delEasting + Math.Cos(-rotationRad) * delNorthing;
                    }
                }
            }
            //return sufficient information to compare various coverage options
            return covSummary;
        }
コード例 #7
0
ファイル: Form1.cs プロジェクト: jekain314/KMLReader
        //////////////////////////////////////
        //all the action occurs here
        //////////////////////////////////////
        private void prepareKML()
        {
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            // this procedure is called immediately after we have clicked the BROWSE button and selected the input file
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            //filestream to create the files where we will write some summary output (debug: KMLDebugFile)
            FileStream fs1;
            try
            {
                //debug output data
               fs1 = new FileStream(datasetFolder + "\\KMLDebugFile.txt", FileMode.Create, FileAccess.Write, FileShare.None);
               outfile = new StreamWriter(fs1);
               outfile.AutoFlush = true;
            }
            catch { MessageBox.Show("Cant open the KMLDebugFile file "); }

            //Constants.Log -- writes the the RTF on the main page of the GUI
            Constants.Log("File opened for writing log information:  \n" + datasetFolder + "\\KMLDebugFile.txt");

            //First determine whether the mission is a linear or area mission
            //In Google Earth -- use the Polygon tool for the polygon and the Path tool for the linear feature
            //can detect these by inspecting the input KML
            //Path has only a LineString tag and coordonate tag
            //Polygon has a Polygon tag, OuterBoundaryIs tag, linearRing tag, coordinates tag

            //get the lat/lon client data and other info from the input kml file
            InspectKMLforMissions kml = new InspectKMLforMissions(kmlInputFilename, datasetFolder, outfile);

            //generate polygon or linearFeature geometry information and further populate the job definition structure
            //convert geodetic to UTM coordinates, compute area, bounding box, etc ...
            COVERAGE_TYPE polyCoverageType_polygonOrLinear = kml.polygonGeometry();

            //expand the poly boundary for insurance -- destroying the original polygon
            if (polyCoverageType_polygonOrLinear == COVERAGE_TYPE.polygon)
            {
                //original lat-lon poonts saved in originalLatitudeDeg, originalLongitudeDeg within poly description
                double borderWidth = 10;  //probably should be adaptive to 1/2 the swath width !!
                kml.expandPolygonVertices(borderWidth);  //expand the client poly vertices with a border for insurance
            }

            //get the airports that are close to the Job polygons
            kml.getAirports();

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //We plan to allow three levels of naming:  job, project, polygon
            //the original idea was that job = the overall job containing projects and individual polygons in a job
            //an example would be
            //job:          agricultureFieldsForDate
            //Project:      FarmerJohn, FarmerJoe
            //polygon:      field#1, field#2, etc
            //However, the current setup is that we have a single polygon in the input kml file
            //we will use the polygon.name for the output kml file --- that becomes the flight plan for the flight computer
            /////////////////////////////////////////////////////////////////////////////////////////////////////////////

            //retrieve a local copy of the Project Polygons from the client-input kml
            //shared for the polygon and linear feature coverage
            polys = new List<Polygon>();  //do we need this statement ???
            polys = kml.getPolygonsFromKML();

            //must see if the input kml file and the polygon.name are the same.
            //if polygon name and inut polygon name are the same, the input file will be deastroyed (over-written)
            //if names are the same:  add "_input" to the original name
            DirectoryInfo kmlInfo = new DirectoryInfo(kmlInputFilename);
            String inputFilenameWOextension = Path.GetFileNameWithoutExtension(kmlInputFilename);
            if (inputFilenameWOextension == polys[0].PolygonName)
            {
                MessageBox.Show("Google Earth placemark name same as input kml filename. \n" +
                         "Input kml name changed by appending  _input  at the end");
                String newName = Path.GetDirectoryName(kmlInputFilename) + "\\" + inputFilenameWOextension + "_input.kml";
                System.IO.File.Move(kmlInputFilename, newName);
                Constants.Log("");
                Constants.Log("The input kml fileName and the Google Earth Placemark name are the same");
                Constants.Log("The input kml filename has been changed by adding _input to its fileName");
                Constants.Log("The prepared mission plan will have the name of the original kml file");
                Constants.Log("Use the new kml filename (with _input) on any new flight planning exercise");
            }

            ////////////////////////////////////////////////////////////////////////////////////
            //at this point, we have the polygon selected as well as the nearby airports
            ////////////////////////////////////////////////////////////////////////////////////

            /////////////////////////////////////////////////////////////////
            //Cycle through all the Project Polygons
            // for now -- we only allow a single poly at a time
            //however, the kml read program allows mpre than one at a time
            //this would be useful for clients with a lot of polygon areas
            ////////////////////////////////////////////////////////////////
            //for (int totIt=0; totIt<4; totIt++)
            {
                //disable the browse button after the input kml selection has been completed
                button1.Visible = false;
                button1.Enabled = false;

                Polygon p = polys[0];

                //we need to display the airports and allow the user to select a project airport.
                //show the airport list in a datGridView and wait for the user to select the correct airport.
                foreach (airport apt in p.airports) this.dataGridView1.Rows.Add(apt.name, apt.distanceToPolyCenterMi.ToString("F1"));
                Constants.Log(" ");
                Constants.Log("Please select a takeoff airport from the dropdown list ");

                this.dataGridView1.Enabled = true;
                this.dataGridView1.Visible = true;
                this.dataGridView1.CurrentCell.Selected = false;

                this.label2.Enabled = true;
                this.label2.Visible = true;
                //wait here while the user selects the takeoff airport
                //the selected airport is given:  selectedAirportIndex
                while (!airportSelected)
                {
                    Application.DoEvents();
                }
                Constants.Log("Selected airport:  " + p.airports[selectedAirportIndex].name);

                Constants.Log("   ");
                Constants.Log("Please  select a camera .... ");

                this.listBox2.Enabled = true;
                this.listBox2.Visible = true;
                this.label1.Enabled = true;
                this.label1.Visible = true;

                //wait here for the user to select a camera
                while (!cameraSelected)
                {
                    Application.DoEvents();  //wait for user inputs
                }
                String cameraType = this.listBox2.SelectedItem.ToString();

                Constants.Log("   ");
                Constants.Log("Please  select a resolution (cm) .... ");

                this.listBox3.Enabled = true;
                this.listBox3.Visible = true;
                this.label3.Enabled = true;
                this.label3.Visible = true;

                //wait here for the user to select a resolution
                while (!ResolutionSelected)
                {
                    Application.DoEvents();  //wait for user inputs
                }

                //no need to select max flight line for a linear feature path coverage
                if (p.polyCoverageType == COVERAGE_TYPE.polygon)
                {
                    Constants.Log("   ");
                    Constants.Log("Please  select a max Flightline Length (nm) .... ");

                    this.listBox4.Enabled = true;
                    this.listBox4.Visible = true;
                    this.label4.Enabled = true;
                    this.label4.Visible = true;

                    //wait here for the user to select a max flight line length
                    while (!maxFLSelected)
                    {
                        Application.DoEvents();  //wait for user inputs
                    }

                    //no need to select max mission time for a linear feature path coverage
                    //assume the user will make the linear features of flyable lengths
                    Constants.Log("   ");
                    Constants.Log("Large coverages may require multiple flight missions. ");
                    Constants.Log("Please  select a maximum per-mission ferry+overtarget flight time (hrs) .... ");

                    this.listBox6.Enabled = true;
                    this.listBox6.Visible = true;
                    this.label6.Enabled = true;
                    this.label6.Visible = true;

                    //wait here for the user to select a max mission time
                    while (!maxMissionTimeSelected)
                    {
                        Application.DoEvents();  //wait for user inputs
                    }
                }
                else
                {
                    this.panel1.Enabled = true;
                    this.panel1.Visible = true;
                    radioButton1.Checked = false;
                    radioButton2.Checked = false;
                    radioButton3.Checked = false;
                    //wait here for the user to select the number of prlallel paths
                    while (!linearFeaturePathsSelected ||
                        (radioButton1.Checked == false &&
                        radioButton2.Checked == false &&
                        radioButton3.Checked == false)  )

                    {
                        Application.DoEvents();  //wait for user inputs
                    }
                    if      (radioButton1.Checked == true) {linearPathCentering = LINEAR_PATH_CENTERING.centeredOnInputPath; }
                    else if (radioButton2.Checked == true) {linearPathCentering = LINEAR_PATH_CENTERING.offsetToLeftOfInputPath; }
                    else if (radioButton3.Checked == true) {linearPathCentering = LINEAR_PATH_CENTERING.offsetToRightOfInputPath; }
                }

                Constants.Log("   ");
                Constants.Log("Please  select a nominal aircraft speed (knots) .... ");

                this.listBox5.Enabled = true;
                this.listBox5.Visible = true;
                this.label5.Enabled = true;
                this.label5.Visible = true;

                //wait here for the user to select a aircraft speed
                while (!nominalSpeedSelected)
                {
                    Application.DoEvents();  //wait for user inputs
                }

                p.selectedAirportIndex = selectedAirportIndex;

                //////////////////////////////////////////////////////////////////////////
                //at this point, we have completed all the user's initial inputs.
                //next we compute the performance for the three coverage types

                ////////////////SETUP PARAMETERS///////////////////////////////////////////////////////////////////
                ///  specific setup for the Canon 5D rotated 90 deg (long side downrange)
                //double flightAlt = 3500.0; //5,000 provides about 6" resolution  -- !!!!!!!!!!this is assumed to be agl!!!!!!!!!!!
                //compute the flight line spacing from the camera FOV and altitude
                double CRFOV = 27.5;    //degrees crossrange FOV (rotated 5D with 50m lenses -- GeoPod)
                double DRFOV = 39.0;      //degrees downrange FOV (rotated 5D with 50mm lens)
                double downlap = 60;    //percent downlap X 100 -- 60
                double sideLap = 30.0;  //percent sidelap X 100
                int cameraPixels = 3744;  //pixels in crossrange  (rotated canon 5D)

                //max FL length is in nautical miles
                double maxFLLengthMi = maxFLLengthNM  * 1.15078;  //convert nautical miles to statute miles

                double timeToTurn = 1.0 / 60.0; //hours   -- about 2 min -- this is conservative 1.5 is typical
                double aircraftSpeedKnots = nominalSpeed; // 100.0;

                double takeoffTime = 5.0 / 60.0;    //time to roll/run-up on the runway turing the takeoff event -- added to the ferry time
                double landingTime = 5.0 / 60.0;    //time in pattern & taxi roll on the runway turing the landing event -- added to the ferry time

                //we attempt to merge small lines (below minLineLength) with prior lines
                double minLineLength = 8.0;   //minimum length of a flight line segment (units km)

                ///////////////////////////////////////////////////////////////////////////////////////////////////////////

                //derived setup parameters/////////////////////////////////////////////////////////////////////////////////////////////////
                //double swathWidth = 2.0 * Math.Tan(CRFOV * Constants.Deg2Rad / 2.0) * flightAlt;  //in feet
                //double GSD = swathWidth / cameraPixels * 0.3048;  //GSD im meters

                double swathWidthMeters = resolutionCm * cameraPixels / 100.0;
                double flightAlt = swathWidthMeters / (2.0 * Math.Tan(CRFOV * Constants.Deg2Rad / 2.0)) / 0.3048;

                double swathWidthWithSidelap = (1.0 - sideLap / 100.0) * swathWidthMeters; //in meters
                double swathWidthKm = swathWidthWithSidelap / 1000.0;  //Km

                //set the max flight line length
                double maxFLLengthKm = maxFLLengthMi * 5280.0 * 0.3048 / 1000.0;
                outfile.WriteLine();
                outfile.WriteLine("Input flight line length is: " + maxFLLengthMi.ToString("F1") + " (mi)  " + maxFLLengthKm.ToString("F1") + "( km)" );

                //downrange image spacing including downlap
                //below used to compute the number of images per flight line
                double DRImageHeightWithDownlap = (1.0 - downlap / 100.0) * 2.0 * Math.Tan(DRFOV * Constants.Deg2Rad / 2.0) * flightAlt; //in feet

                //same as above but in km -- distance downrange between each image trigger
                double DRImageHeightKm = DRImageHeightWithDownlap * 0.3048 / 1000.0;  //Km

                double aircraftSpeedKPH = aircraftSpeedKnots * 0.514 / 1000 * 3600.0;  //0.514 m/sec per knot -- 100 knots = 51.4 m/s

                double forwardSpeedInClimb = 0.70 * aircraftSpeedKPH;  //limit the forward speed when the aircraft is climbing to altitude
                double avgClimbRate = 500.0;   //ft per minute -- climb rate
                double minimumFerryTime = (flightAlt / avgClimbRate) / 60.0;     //time to climb to altitude
                double distanceDuringClimb = forwardSpeedInClimb * minimumFerryTime;            //horizontal distance traveled during the climb to altitude
                //note -- this can make a flight line exceed the max length -- but not by too much.
                //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                ///////////////////////////////////////////////////////////////////////////////
                //at this point, we have the camera parameters
                //and all the coordinates of the polygon or linear path
                ///////////////////////////////////////////////////////////////////////////////

                //compute the LinearFeature coverage --- The below procedure will terminate the Planner
                if (p.polyCoverageType == COVERAGE_TYPE.linearFeature)
                {
                    LinearFeaturePlanner(p, flightAlt, swathWidthKm, aircraftSpeedKnots, aircraftSpeedKPH, DRImageHeightKm);
                }

                //////////////////////////////////////////////////////////////////////////
                //we will get to the below functionality only for the polygon planner
                //////////////////////////////////////////////////////////////////////////

                //now determine if we prefere a NS or EW mission plan
                //compute the north-to-south distance wherein we will space the flightlines
                double NSDstanceKm = (p.maxNorthing - p.minNorthing) / 1000.0;
                double EWDstanceKm = (p.maxEasting - p.minEasting) / 1000.0;
                double NSDstanceMi = (p.maxNorthing - p.minNorthing) / 0.3048 / 5280.0;
                double EWDstanceMi = (p.maxEasting - p.minEasting) / 0.3048 / 5280.0;

                btnNS_EW.Visible = true;
                btnNS_EW.Enabled = true;

                int numSets = 0;
                int numFlightLines = 0;
                int maxSets = 20;
                int maxFlightLines = 200;
                double[, ,] XAllSets = new double[2, maxSets, maxFlightLines];
                double[, ,] YAllSets = new double[2, maxSets, maxFlightLines];

                ///////////////////////////////////////////////////////////////////////////////////////////
                //get the polygon coverage for three types of coverage and present the results to the user
                ///////////////////////////////////////////////////////////////////////////////////////////
                COVERAGE_SUMMARY covSummary1 =
                    getPolygonFlightPathCoverage(0.0,                               //North-South case
                            p, swathWidthKm, maxFLLengthKm, minLineLength, DRImageHeightKm,
                            ref numSets, ref numFlightLines, ref XAllSets, ref YAllSets);

                COVERAGE_SUMMARY covSummary2 =
                    getPolygonFlightPathCoverage(90.0 * Constants.Deg2Rad,          //East-West case
                            p, swathWidthKm, maxFLLengthKm, minLineLength, DRImageHeightKm,
                            ref numSets, ref numFlightLines, ref XAllSets, ref YAllSets);

                COVERAGE_SUMMARY covSummary3 =                                      //principal axis case
                    getPolygonFlightPathCoverage((180.0-p.rotationAngleDeg) * Constants.Deg2Rad,
                            p, swathWidthKm, maxFLLengthKm, minLineLength, DRImageHeightKm,
                            ref numSets, ref numFlightLines, ref XAllSets, ref YAllSets);
                double flightTime1 = covSummary1.totalFlightLineLength / aircraftSpeedKPH + (covSummary1.numTotalFlightLines - 1) * timeToTurn;
                double flightTime2 = covSummary2.totalFlightLineLength / aircraftSpeedKPH + (covSummary2.numTotalFlightLines - 1) * timeToTurn;
                double flightTime3 = covSummary3.totalFlightLineLength / aircraftSpeedKPH + (covSummary3.numTotalFlightLines - 1) * timeToTurn;

                //display the results to the user and allow user to select from among the types of coverage
                Constants.Log("");
                Constants.Log(" Coverage Options: ");
                Constants.Log("      Type                  #FL      AvgFL (km)        TotalLength (km)    Time (hrs)  ");
                String fmt1 = String.Format("NorthSouth       \t{0,5}      \t{1,8:##.00}       \t{2,10:###.00}        \t{3,6:#.00}",
                    covSummary1.numTotalFlightLines, covSummary1.averageFlightLineLength, covSummary1.totalFlightLineLength, flightTime1);
                Constants.Log(fmt1);
                String fmt2 = String.Format("EastWest         \t{0,5}       \t{1,8:##.00}       \t{2,10:###.00}        \t{3,6:#.00}",
                    covSummary2.numTotalFlightLines, covSummary2.averageFlightLineLength, covSummary2.totalFlightLineLength, flightTime2);
                Constants.Log(fmt2);
                String fmt3 = String.Format("PrincipalAxis    \t{0,5}       \t{1,8:##.00}       \t{2,10:###.00}         \t{3,6:#.00}",
                    covSummary3.numTotalFlightLines, covSummary3.averageFlightLineLength, covSummary3.totalFlightLineLength, flightTime3);
                Constants.Log(fmt3);
                outfile.WriteLine();
                outfile.WriteLine("Results of three types of coverage ");
                outfile.WriteLine(fmt1);
                outfile.WriteLine(fmt2);
                outfile.WriteLine(fmt3);

                //select the recommended coverage option from the three candidates
                if (flightTime1 < flightTime2 && flightTime1 < flightTime3)
                    { btnNS_EW.Text = "North-South";    polyCoverageType = PolygonCoverageType.South2North; };
                if (flightTime2 < flightTime1 && flightTime2 < flightTime3)
                    { btnNS_EW.Text = "East-West";      polyCoverageType = PolygonCoverageType.East2West; };
                if (flightTime3 < flightTime1 && flightTime3 < flightTime2)
                    { btnNS_EW.Text = "PrincipleAxis";  polyCoverageType = PolygonCoverageType.PrincipalAxis; };

                //enable the missionPlan startup button.
                button3.Visible = true;
                button3.Enabled = true;

                ///////////////////////////////////////////////////////////////////////////////////
                //  wait here til user clicks considers the coverage options and clicks:  "PLAN"
                ///////////////////////////////////////////////////////////////////////////////////

                while (!MissionPlanningInitiated)
                {
                    Application.DoEvents();  //wait for user inputs
                }

                //redo  the polygon coverage based on the user selection  --
                //need to save the old plans so we dont have to redo!!
                if ( polyCoverageType == PolygonCoverageType.South2North)
                    getPolygonFlightPathCoverage(0.0,                               //North-South case
                            p, swathWidthKm, maxFLLengthKm, minLineLength, DRImageHeightKm,
                            ref numSets, ref numFlightLines, ref XAllSets, ref YAllSets);
                else if (polyCoverageType == PolygonCoverageType.East2West)
                    getPolygonFlightPathCoverage(90.0 * Constants.Deg2Rad,          //East-West case
                            p, swathWidthKm, maxFLLengthKm, minLineLength, DRImageHeightKm,
                            ref numSets, ref numFlightLines, ref XAllSets, ref YAllSets);
                else if (polyCoverageType == PolygonCoverageType.PrincipalAxis)
                    getPolygonFlightPathCoverage((180.0-p.rotationAngleDeg) * Constants.Deg2Rad,
                            p, swathWidthKm, maxFLLengthKm, minLineLength, DRImageHeightKm,
                            ref numSets, ref numFlightLines, ref XAllSets, ref YAllSets);

                //this is placed here just in case the user has changed his mind and re-clicked a different airport
                p.selectedAirportIndex = selectedAirportIndex;

                GoogleMaps gglmaps = new GoogleMaps(datasetFolder, p.PolygonName);
                gglmaps.getGoogleMapToCoverProject(ref p, downloadMap);  //insert the Google map from the web into this polygon

                /////////////////////////////////////////////////////////////////////////////////
                bool replannerTool = false;     //set true for a replanner tool
                /////////////////////////////////////////////////////////////////////////////////

                //this is for a replanner tool
                // what does this do ?????
                //supposed to allow visual editing of the Quick-Look and replanning the mission to cover clouds & shadows
                List<endPoints> reflyLines = null;
                ReflyPlanner refly;

                if (replannerTool)
                {
                    refly = new ReflyPlanner(@"E:\Melbourne\Melbourne_NEW_005\QLData\refly_005.kml", p);
                    MessageBox.Show("refly tool is in effect");
                    //should have a way to indicate which photocenters are to be reflown
                    reflyLines = refly.getReflySegments();
                }
                /////////////////////////////////////////////////////////////////////////////////

                //open the file to write the kml Project results
                kmlOutputFilename = datasetFolder + "\\" + p.PolygonName + ".kml";

                //NOTE: this will fail if the input client polygon (.kml) is the same as the desired output kml

                FileStream fs2 = null;
                try
                {
                    fs2 = new FileStream(kmlOutputFilename, FileMode.Create, FileAccess.Write, FileShare.None);
                }
                catch
                {
                    MessageBox.Show("cant open the kml Project results file -- input file cannot be same as output file ");
                }
                kmlFlightLines = new StreamWriter(fs2);  //kml file where we will write
                kmlFlightLines.AutoFlush = true;

                //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                //at this point, we have a 2D table YAllSets[numsets][numFlightLines] that describes the intended flightlines and lengths
                //however, some of these have zero length because of the irregular shape of the polygon
                //Moreover, we have not considered the max endurance -- so we must collect sequentual flightlines into flyable missions
                //Below we convert the 2D structure to a 1D structure containing only flightlines to be flown
                //we also assign the flightlines to individual missions
                //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                outfile.WriteLine();
                outfile.WriteLine("Now have the set of flight lines by set");
                outfile.WriteLine("Next break up these flight lines into time-constrained groupings to get a mission");
                outfile.WriteLine();

                Constants.Log("Accumulate flight lines into missions based on max mission length");

                //go through the flightlines for a set and determine the total time-over-the-covered area for the complete Set
                //If this is > 2 hrs, then break the set into ~equal Area Of Interest (AOI) flight sessions "AOITimeMax".
                //find the start-end flightline for AOIs so the accumulated AOITime < AOITimeMax  -- except the last AOI may be larger

                List<MissionSummary> MissionSumA = new List<MissionSummary>();
                //set up for the polygon math
                polygonMath polyMath = new polygonMath(p.Easting, p.Northing, datasetFolder);

                double totalFlightlineDistance = 0;
                double flightlineDistanceThisMission = 0;
                int missionNumber = 0;
                int totalImages = 0;
                int totalImagesThisMission = 0;
                int startFlightlineThisMission = 0;
                double sumMissionLat = 0.0;  //used to compute the average mission center (average lat/lon)
                double sumMissionLon = 0.0;
                double totalFerryTime = 0.0;
                double totalTimeToTurn = 0.0;
                double totalTimeOverTarget = 0.0;

                double latStart = 0, lonStart = 0;
                double latEnd = 0, lonEnd = 0;
                int jApt = 0;  //airport counter
                double ferryTime = 0.0;
                double oldFerryTime = 0.0;
                int numberFlightlines = 0;

                outfile.Flush();

                double avgMissionLat=0.0; double avgMissionLon=0.0;

                int numFL = 0;  //numFL becomes the sequential flight line counter for the 1D array that will persist across the project
                for (int i = 0; i < numSets; i++)
                {

                    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    //compute the max allowable AOITime for this Set
                    double maxAOITime = maxMissionTimeHrs; //maxAOITimeGlobal;
                    outfile.WriteLine("Input Maximum Mission time is set to " + maxMissionTimeHrs.ToString());

                    double totalFlightlineDistancePerSet = 0; int numFLthisSet=0;
                    int lastNonZeroFLThisSet = 0;
                    //precompute the total time to cover the flight lines in this set
                    for (int j = 0; j < numFlightLines; j++)
                    {
                        double FLLength = 0;
                        double delEasting  = XAllSets[1, i, j] - XAllSets[0, i, j];
                        double delNorthing = YAllSets[1, i, j] - YAllSets[0, i, j];
                        FLLength = Math.Sqrt(delEasting*delEasting + delNorthing * delNorthing);

                        if (FLLength > 0)
                        {
                            numFLthisSet++;
                            totalFlightlineDistancePerSet += FLLength;

                            lastNonZeroFLThisSet = j;
                        }

                    }
                    //total time for this set
                    double totalAOITime = (totalFlightlineDistancePerSet / 1000.0) / aircraftSpeedKPH + (numFLthisSet - 1) * timeToTurn;

                    double numberOfAOIsThisSet = Math.Floor(totalAOITime / maxAOITime) + 1.0;
                    //adjust the maxAOITime so that it is <= to the input maxAOITime but equal for all missions within this set
                    maxAOITime = totalAOITime / numberOfAOIsThisSet;
                    outfile.WriteLine();
                    outfile.WriteLine("Number of missions this set = " + numberOfAOIsThisSet.ToString());
                    outfile.WriteLine("Adjusted Maximum Mission time to enforce equal-size missions this set " + maxAOITime.ToString("F1"));
                    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    //max allowable is now <= the initial max allowable -- reduced to have neary equal sized AOIs within the set.
                    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                    int AOIsThisSet = 0;

                    ////////////////////////////////////////////////////////////////////////////////////
                    //now go back through the flight lines and break into groupings of flight lines
                    //this will define the flyable missions with a prescribed time-over-target threshold
                    ////////////////////////////////////////////////////////////////////////////////////
                    for (int j = 0; j < numFlightLines; j++)
                    {
                        //compute the flight line length using the north and south intersection extents
                        //YAllSets[1, i, j] is the flight line "end" -- the larger Northing value (i.e., northmost end)
                        double flightLineDistanceKm = 0;
                        double delEasting = XAllSets[1, i, j] - XAllSets[0, i, j];
                        double delNorthing = YAllSets[1, i, j] - YAllSets[0, i, j];
                        flightLineDistanceKm = Math.Sqrt(delEasting * delEasting + delNorthing * delNorthing) / 1000.0;

                        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                        if (flightLineDistanceKm == 0 ) continue;  //skip the below computations id the terminated flight line has zero length
                        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                        //number of flightlines this mission is current flight line (numFL) minus start flight line
                        numberFlightlines = numFL - startFlightlineThisMission + 1;  //num of flight lines this mission

                        //sum the total flight line distances
                        //images this flight line based on the downrange image extent
                        int imagesThisFlightline = Convert.ToInt32(Math.Floor(flightLineDistanceKm / DRImageHeightKm)  + 1.0);

                        //per-mission and total travel distances and num of images
                        totalFlightlineDistance += flightLineDistanceKm;
                        flightlineDistanceThisMission += flightLineDistanceKm;
                        totalImages += imagesThisFlightline;
                        totalImagesThisMission += imagesThisFlightline;

                        //transfer the start/end UTM coordinates back to the LatLon for use in the kml file
                        //Y is northing and X is easting
                        utm.UTMtoLL(YAllSets[0, i, j], XAllSets[0, i, j], p.UTMZone, ref latStart, ref lonStart);
                        utm.UTMtoLL(YAllSets[1, i, j], XAllSets[1, i, j], p.UTMZone, ref latEnd, ref lonEnd);

                        FLSum[numFL].planned.startUTMX = XAllSets[0, i, j];
                        FLSum[numFL].planned.startUTMY = YAllSets[0, i, j];
                        FLSum[numFL].planned.endUTMX = XAllSets[1, i, j];
                        FLSum[numFL].planned.endUTMY = YAllSets[1, i, j];

                        //fill the flightline summary structure
                        FLSum[numFL].planned.startLat = latStart;
                        FLSum[numFL].planned.startLon = lonStart;
                        FLSum[numFL].planned.endLat = latEnd;
                        FLSum[numFL].planned.endLon = lonEnd;

                        FLSum[numFL].numImages = imagesThisFlightline;

                        FLSum[numFL].lineNumberInPolygon = numFL;
                        FLSum[numFL].flightlineLengthMi = flightLineDistanceKm * 1000.0 / 0.3048 / 5280.0;
                        FLSum[numFL].FLstat = fightlineStatus.plan;

                        //sums to be used to compute the average mission center
                        sumMissionLat += (FLSum[numFL].planned.startLat + FLSum[numFL].planned.endLat) / 2.0;
                        sumMissionLon += (FLSum[numFL].planned.startLon + FLSum[numFL].planned.endLon) / 2.0;

                        ///////////////////////////////Closest Airport///////////////////////////////////////////////////////////////////
                        //average mission lat/lon for use in getting the ferry distance
                        //we keep a running sum to get the avg as we add flight lines to the mission
                        avgMissionLat = sumMissionLat / numberFlightlines;
                        avgMissionLon = sumMissionLon / numberFlightlines;

                        /*
                        //closest airport and ferry time to average mission location
                        //test all candidate airports and use the closest to the mission center
                        double minAptDistance = 99999999999999.0;
                        for (int jA = 0; jA < p.airports.Count; jA++)
                        {
                            double delLat = p.airports[jA].lat - avgMissionLat;
                            double delLon = p.airports[jA].lon - avgMissionLon;
                            double dist = Math.Sqrt(delLat * delLat + delLon * delLon);
                            if (dist < minAptDistance) { minAptDistance = dist; jApt = jA; }  //store the index of the closest airport
                        }
                        */

                        double aptNorthing = 0.0, aptEasting = 000, avgNorthing = 0.0, avgEasting = 0.0;
                        //convert the airport lat/Long (LL) coordinates to UTM for distance measurement
                        utm.LLtoUTM(p.airports[p.selectedAirportIndex].lat * Constants.Deg2Rad, p.airports[p.selectedAirportIndex].lon * Constants.Deg2Rad,
                            ref aptNorthing, ref aptEasting, ref p.UTMZone, true);
                        utm.LLtoUTM(avgMissionLat * Constants.Deg2Rad, avgMissionLon * Constants.Deg2Rad, ref avgNorthing, ref avgEasting, ref p.UTMZone, true);
                        //delta N and E distances in Miles
                        double dn = (aptNorthing - avgNorthing) / 1000.0;
                        double de = (aptEasting - avgEasting) / 1000.0;

                        //ferry distance one-way -- approximation cause the ferry time really to the start of the first line of this mission
                        double ferryDistanceKm = Math.Sqrt(dn * dn + de * de);

                        oldFerryTime = ferryTime; // save the last ferry time --- new ferry time assuming we keep the current mission is below
                        if (ferryDistanceKm > distanceDuringClimb) //account for the travel portion while climbing to altitude
                            ferryTime = minimumFerryTime + (ferryDistanceKm - distanceDuringClimb) / aircraftSpeedKPH +
                                ferryDistanceKm / aircraftSpeedKPH + takeoffTime + landingTime;
                        else  //closest airport is inside the mission area -- climb time is purely addidive to the flight time
                            ferryTime = minimumFerryTime + ferryDistanceKm / aircraftSpeedKPH + takeoffTime + landingTime;
                        /////////////////////////////////Closest AIRPORT////////////////////////////////////////////////////////////////

                        numFL++;  //number of flight lines that have been investigated

                        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                        //separate the flight lines into multiple missions by asking: If we add this flight line do we exceed the aircraft endurance?
                        //also do this for the last flightline in each Set -- and the very last flight line.
                        //note -- on the first entry, we havent computed a ferry time (its zero) but its computed below

                        double expectedAOITime = (flightlineDistanceThisMission) / aircraftSpeedKPH + (numberFlightlines - 1) * timeToTurn;

                        outfile.WriteLine(String.Format(" New flightline: {0,2} length {1,10:#.00} (mi) accumulated Time = {2,10:#.00}",
                            numFL, flightLineDistanceKm * 1000.0 / 0.3048 / 5280.0, expectedAOITime));
                        outfile.Flush();

                        //NOTE: expectedAOITime includes the current line being tested
                        //will we allow each AOI to be slightly larger than maxAOITime (by one flight line) or force each AOI to be smaller by one flight line?
                        //for the first case, we will end up with a short AOI at the end -- for the second case, we end up with a long AOI at the end.
                        //at the very end, we always want to set the prior lines in this Set as an AOI

                        //first part of the "if" test tests to see if adding this flight line exceeds the maxAOITime.
                        //note that this test is removed if we are at the last AOI within a set. This allows the last AOI to be established
                        //even though the AOITime is below the maxAOITime. The second part of the "if" test triggers the AOI at the very last nonzero flightline.

                        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                        if ((expectedAOITime > maxAOITime && AOIsThisSet != (numberOfAOIsThisSet-1) ) || (j == lastNonZeroFLThisSet))
                        {

                            AOIsThisSet++;

                            //numFL is the total number of flight lines that have been processed below
                            //numFL-1 is the flightline ID of the last fight line that was processed
                            //numFL will be the next flight line process so is the start line of the next mission

                            //below logic accounts for the potential staggered start and ends of flight lines
                            //these computations assume you start at the west headed north and turn back south after each north-going line, alternating north/south directions
                            double extendedTravelToNextLine = 0; // accounts for the distance to travel to the start of the next flight line
                            for (int k = startFlightlineThisMission; k < (numFL-2) ; k += 2)
                            {
                                //account for extended line going north and turning south  (end is at the north)
                                extendedTravelToNextLine += Math.Abs(FLSum[k].planned.endUTMX - FLSum[k + 1].planned.endUTMX) / 1000.0;
                                //account for extended line going south and turning north (start is at the south)
                                extendedTravelToNextLine += Math.Abs(FLSum[k + 1].planned.startUTMX - FLSum[k + 2].planned.startUTMX) / 1000.0;
                            }

                            flightlineDistanceThisMission += extendedTravelToNextLine;

                            totalTimeToTurn += (numberFlightlines - 1) * timeToTurn;

                            //Store the mission summary data into a structure and add to the ArrayList Collection
                            MissionSummary missionSum = new MissionSummary();
                            missionSum.missionPolygon = new List<PointD>();  // this is a geodetic polygon formed from the flight line endpoints
                            missionSum.missionNumber = missionNumber;   //incremental index of the missions
                            missionSum.startFlightLine = startFlightlineThisMission; //starting flight line for this mission
                            missionSum.FerryTime = ferryTime;   //two-way ferry --- computed below
                            missionSum.LengthMi = flightlineDistanceThisMission * 1000.0 / 0.3048 / 5280.0;
                            missionSum.numberFlightlines = numberFlightlines;  //
                            missionSum.TimeOverTarget = flightlineDistanceThisMission / aircraftSpeedKPH + (numberFlightlines - 1) * timeToTurn;
                            totalTimeOverTarget += missionSum.TimeOverTarget;
                            missionSum.MissionStat = MissionStatus.plan;
                            missionSum.takeoffAirport = p.airports[jApt];
                            missionSum.totalImages = totalImagesThisMission;
                            missionSum.backgroundImageNWCorner = new PointD(0.0, 0.0);
                            missionSum.backgroundImageSECorner = new PointD(0.0, 0.0);
                            outfile.WriteLine(String.Format(" new misson:  {0,2} startFlightLine {1,3} numFlightLines {2,3} flightlineDistance {3,10:#.00} (Mi) ferryTime {4,5:#.00} (hr) ",
                                 missionSum.missionNumber, missionSum.startFlightLine, missionSum.numberFlightlines, missionSum.LengthMi, missionSum.FerryTime));

                            missionSum.backgroundImageFilename = "NA";
                            missionSum.setNumber = i;

                            if (!replannerTool)
                            {
                                //form a polygon of the mission envelope based upon the flight line endpoints.
                                //I dont see where these UTM endpoints are used!!!
                                List<double> EastingMsn = new List<double>(); List<double> NorthingMsn = new List<double>();
                                //go around the flight line endpoints beginning at the south ends and moving counterclockwise
                                for (int ifl = startFlightlineThisMission; ifl < (startFlightlineThisMission + numberFlightlines); ifl++)
                                {
                                    EastingMsn.Add(FLSum[ifl].planned.startUTMX);
                                    NorthingMsn.Add(FLSum[ifl].planned.startUTMY);
                                    missionSum.missionPolygon.Add(new PointD(FLSum[ifl].planned.startLon, FLSum[ifl].planned.startLat));
                                }
                                //add the north ends starting at the westmost lines so the poly forms a sequential set of points counterclockwise
                                for (int ifl = (startFlightlineThisMission + numberFlightlines - 1); ifl > startFlightlineThisMission - 1; ifl--)
                                {
                                    EastingMsn.Add(FLSum[ifl].planned.endUTMX);
                                    NorthingMsn.Add(FLSum[ifl].planned.endUTMY);
                                    missionSum.missionPolygon.Add(new PointD(FLSum[ifl].planned.endLon, FLSum[ifl].planned.endLat));
                                }
                                //add one more point back at the start to create a linesegment to close the polygon
                                missionSum.missionPolygon.Add(new PointD(FLSum[startFlightlineThisMission].planned.startLon, FLSum[startFlightlineThisMission].planned.startLat));
                            }
                            else
                            {
                                //form the mission polygon from the flight line bounding boxes
                                double maxLat = -99999.0, maxLon = -99999.0;
                                double minLat =  99999.0, minLon =  99999.0;
                                foreach (endPoints ep in reflyLines)
                                {
                                    if (ep.startLat > maxLat) maxLat = ep.startLat;
                                    if (ep.endLat > maxLat) maxLat = ep.endLat;
                                    if (ep.startLon > maxLon) maxLon = ep.startLon;
                                    if (ep.endLon > maxLon) maxLon = ep.endLon;
                                    if (ep.startLat < minLat) minLat = ep.startLat;
                                    if (ep.endLat < minLat) minLat = ep.endLat;
                                    if (ep.startLon < minLon) minLon = ep.startLon;
                                    if (ep.endLon < minLon) minLon = ep.endLon;
                                }
                                missionSum.missionPolygon.Add(new PointD(minLon-0.01, maxLat+0.01));
                                missionSum.missionPolygon.Add(new PointD(maxLon+0.01, maxLat+0.01));
                                missionSum.missionPolygon.Add(new PointD(maxLon+0.01, minLat-0.01));
                                missionSum.missionPolygon.Add(new PointD(minLon-0.01, minLat-0.01));
                                missionSum.missionPolygon.Add(new PointD(minLon-0.01, maxLat+0.01));
                            }

                            //mission center/average lat/lon is computed below this statement
                            missionSum.missionCenter = new PointD(avgMissionLat, avgMissionLon);

                            outfile.Flush();

                            //////////// add mission summary  to the ArrayList collection of missions///////////////////////////////
                            MissionSumA.Add(missionSum);

                            totalFerryTime += ferryTime;    //total ferry times across the complete project -- used for the average ferry per mission

                            flightlineDistanceThisMission = 0;  //reset the mission distance summation
                            totalImagesThisMission = 0;         //reset the total images this mission
                            missionNumber++;                    //increment the mission couinter
                            startFlightlineThisMission = numFL; //set the start flight line for the next mission
                            sumMissionLat = 0.0;                //reset the sums used for the current mission lat/lon average
                            sumMissionLon = 0.0;
                        }

                    }
                }

                ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                //cycle back through the missions and get the maps and the average altitude
                //do this in a batch rather than in the per-mission segment above
                //in order to better batch-submit requests to the Google Maps API
                //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                List<PointD> totalPointsInPoly = new List<PointD>();  //a list of Npts points randomly spaced withi each polygon;

                int Npts = 100;  //number of random-spaced points from each mission polygon used to form the average elevation in the mission polygon
                // MissionSumA is the collection of all missions -- this includes the mission polygon that is determined above
                for (int i = 0; i < MissionSumA.Count; i++)
                {
                    ////////////////////////////////////////////////////////////
                    // not quite sure why we do the intermediate storage !!!
                    ////////////////////////////////////////////////////////////
                    MissionSummary missionSum = MissionSumA[i];

                    //get the map of the mission area
                    gglmaps.createBackgroundMaps(ref missionSum, FLSum, p.UTMZone, downloadMap);
                    MissionSumA[i] = missionSum;

                    //get a list of all the accumulated Npts points used for all the averages
                    //this is done so we can request the elevation using Google Maps API with a minimum of requests
                    //  getPointsInPoly returns a list of Npts PointD points -- so the below call adds Npts on each call ???
                    for (int ips = 0; ips < Npts; ips++)
                    {
                        totalPointsInPoly.Add(polyMath.getPointsInPoly(Npts, missionSum.missionPolygon)[ips]);
                    }
                }

                //this procedure gets the elevations for the totalPointsInPoly using the Google Elevation API
                //the points are requested using the polyline request method to minimize the number of requests.
                //we pack as many elevation points into each request as possible within the constraints of the URL length
                //The elevation API limits requests to 2500/day and a total of 25000 elevation points per day.
                //so 2500 requests with 100 points per request will hit the limit.
                List<double> heights = polyMath.getTerrainHeightsFromPointList(totalPointsInPoly);

                //go back through the total list of elevations and break the list into missions and get the elevation stats per mission
                for (int i = 0; i < MissionSumA.Count; i++)
                {
                    MissionSummary missionSum = MissionSumA[i];
                    List<double> heightsThisMission = new List<double>();
                    for (int ips = i * Npts; ips < (i + 1) * Npts; ips++) heightsThisMission.Add(heights[ips]);

                    heightsThisMission.Sort();  //used to get the 90 percentile height

                    missionSum.ts.avgTerrainHeight = heightsThisMission.Average();
                    missionSum.ts.terrain90percentileHeight = heightsThisMission[Convert.ToInt32(0.90 * Npts)];
                    missionSum.ts.maxTerrainHeight = heightsThisMission.Max();
                    missionSum.ts.minTerrainHeight = heightsThisMission.Min();
                    ////flight altitude in feet for the pilot display
                    missionSum.FlightAltMSLft = flightAlt + missionSum.ts.terrain90percentileHeight / 0.3048;  //flightAlt is AGL in ft;
                    ////round to the nearest 100 ft
                    missionSum.FlightAltMSLft = (int)(missionSum.FlightAltMSLft / 100.0 + 0.50) * 100.00;

                    MissionSumA[i] = missionSum;
                }

                ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                //now we have all the data for the missions.
                //we need to write out the xml text lines that will be inserted into the original kml file.
                //we insert beneath the original Placemark element (after the <Placemark> and form a <Folder> kml structure
                //each element in the folders will contain one mission
                //also each mission folder will contain multiple Placemark elements that represent the flightlines
                //note the <description> <!CDATA[   ..... ]]> .... this is inserted HTML code to format the presentation
                //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                Constants.Log(" Write the mission plan .kml");

                ////////////////////////////////
                //write the kml file
                ////////////////////////////////

                writeKmlPolygonMissonPlan(p,
                        DRImageHeightKm, missionNumber, flightAlt, swathWidthKm,
                        totalFlightlineDistance, totalFerryTime, aircraftSpeedKPH,
                        totalTimeOverTarget, numFL, totalImages, MissionSumA);

                ///////////////////////////////////////////////////////////////
                //the above comprises a complete closed set of .kml elements
                ///////////////////////////////////////////////////////////////

                kmlFlightLines.Flush();

                Constants.Log("");
                Constants.Log("");
                Constants.Log("Normal Termination ");
                Constants.Log("");

                //////////////////////////////////////////////
                //show the END button
                button2.Visible = true;
                button2.Enabled = true;
                //////////////////////////////////////////////

            }

            //Application.Exit();
        }
コード例 #8
0
ファイル: Form1.cs プロジェクト: jekain314/KMLReader
        void LinearFeaturePlanner(Polygon p, double flightAlt, double swathWidthKm, 
            double aircraftSpeedKnots, double aircraftSpeedKPH, double DRImageHeightKm)
        {
            //if (p.polyCoverageType == COVERAGE_TYPE.linearFeature)
            //{
                //show the "PLAN" button
                button3.Visible = true;
                button3.Enabled = true;

                ///////////////////////////////////////////////////////////////////////////////////
                //  wait here til user clicks considers the coverage options and clicks:  "PLAN"
                ///////////////////////////////////////////////////////////////////////////////////
                while (!MissionPlanningInitiated)
                {
                    Application.DoEvents();  //wait for user inputs
                }

                //TODO
                //get the flyable aircraft paths that will cover the input linear feature path
                //there will be one linearFeature object for each of the parallel paths
                List<LINEAR_FEATURE> linearFeatures =
                    linearFeatureCoverage(numParallelPaths, linearPathCentering,
                    flightAlt, swathWidthKm * 1000.0, aircraftSpeedKnots * 0.514);

                //the above procedure writes kml files for forward, backward, & smoothed trajectory
                //also writes out the image boresight projection and the image endpoints as kml files

                GoogleMaps ggl = new GoogleMaps(datasetFolder, p.PolygonName);

                //get the project map for the path -- shows complete extent of the path and takeoff airport
                ggl.getGoogleMapToCoverProject(ref p, downloadMap);

                //get the path-segment maps that will be used to form a aircraft-centered sliding window map
                //get rectangular maps sized 10mi x 10mi at 5mi intervals along the path
                ggl.createBackgroundMapsForLinearFeature(linearFeatures, p.UTMZone, downloadMap);

                double totalPathDistance = 0.0;
                polygonMath polymath = new polygonMath(linearFeatures[0].EastingProNavS, linearFeatures[0].NorthingProNavS, datasetFolder);

                //get the along-path altitudes
                for (int iLF = 0; iLF < linearFeatures.Count; iLF++)
                {
                    totalPathDistance += linearFeatures[iLF].pathLength;

                    List<PointD> pointsAlongPath = new List<PointD>();
                    UTM2Geodetic utm = new UTM2Geodetic();
                    //create a sequence of points along path based on the smoothed trajectory
                    for (int i = 0; i < linearFeatures[iLF].NorthingProNavS.Count; i++)
                    {
                        double lat = 0.0, lon = 0.0;
                        utm.UTMtoLL(linearFeatures[iLF].NorthingProNavS[i], linearFeatures[iLF].EastingProNavS[i], p.UTMZone, ref lat, ref lon);
                        pointsAlongPath.Add(new PointD(lon, lat));
                    }
                    //get the terrain heights using the Google Elevation API
                    linearFeatures[iLF].alongPathAltitude = polymath.getTerrainHeightsFromPointList(pointsAlongPath);

                    //number of triggered images along the path
                    linearFeatures[iLF].numImages = (int)(linearFeatures[iLF].pathLength / (DRImageHeightKm * 1000.0));

                    //get stats of the along-path altitudes
                    double maxAlt = -99999.0, minAlt = 99999.0, meanAlt = 0.0;
                    foreach (double alt in linearFeatures[iLF].alongPathAltitude)
                    {
                        if (alt > maxAlt) maxAlt = alt;
                        if (alt < minAlt) minAlt = alt;
                        meanAlt += alt;
                    }
                    meanAlt /= linearFeatures[iLF].alongPathAltitude.Count;
                    linearFeatures[iLF].maxAltitude = maxAlt;
                    linearFeatures[iLF].minAltitude = minAlt;
                    linearFeatures[iLF].meanAltitude = meanAlt;
                    linearFeatures[iLF].pathNumber = iLF;
                }

                //get the 2way ferry distance
                double total2WayFerryDistance = 0.0;
                //start: always start for 0th path to the selected airport
                //distance from selected airport to start of first line
                double delNS = linearFeatures[0].NorthingProNavS[0] - p.airports[selectedAirportIndex].northing;
                double delES = linearFeatures[0].EastingProNavS[0] - p.airports[selectedAirportIndex].easting;
                double distanceToAptS = Math.Sqrt(delNS * delNS + delES * delES);
                total2WayFerryDistance += distanceToAptS;

                //always return to the airport from the end of the last path
                int endIndex = linearFeatures[linearFeatures.Count - 1].NorthingProNavS.Count - 1;
                //distance from selected airport to start of first line
                delNS = linearFeatures[linearFeatures.Count - 1].NorthingProNavS[endIndex] - p.airports[selectedAirportIndex].northing;
                delES = linearFeatures[linearFeatures.Count - 1].EastingProNavS[endIndex] - p.airports[selectedAirportIndex].easting;
                distanceToAptS = Math.Sqrt(delNS * delNS + delES * delES);
                //final 2-way ferry distance is the sum of the to- and from- ferry distances
                total2WayFerryDistance += distanceToAptS;

                double totalPathTime = totalPathDistance / (aircraftSpeedKPH * 1000.0);
                int totalLFImages = (int)(totalPathDistance / (DRImageHeightKm * 1000.0));

                writeKmlLinearFeatureMissonPlan(p,
                        DRImageHeightKm, numParallelPaths, flightAlt, swathWidthKm,
                        totalPathDistance, total2WayFerryDistance, aircraftSpeedKPH,
                        totalPathTime, totalLFImages, linearFeatures);

                //////////////////////////////////////////////
                //show the END button
                button2.Visible = true;
                button2.Enabled = true;
                //////////////////////////////////////////////

                //wait here to see if the user clicks the "END" button
                while (true)
                {
                    Application.DoEvents();
                }

                //Environment.Exit(-1);
            //}
            ////////////////////////  end of linear feature Planner //////////////////
        }