root/FalconView/trunk/public/fvw_core/GeodataDataSources/UtilityMethods.cpp @ 2242

// Copyright (c) 1994-2010 Georgia Tech Research Corporation, Atlanta, GA
// This file is part of FalconView(tm).

// FalconView(tm) is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// FalconView(tm) is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License
// along with FalconView(tm).  If not, see <http://www.gnu.org/licenses/>.

// FalconView(tm) is a trademark of Georgia Tech Research Corporation.

// UtilityMethods.cpp : Implementation of CUtilityMethods

#include "stdafx.h"
#include "UtilityMethods.h"
#include "comutil.h"
#include <string>
#include "FvOGRPoint.h"
#include "FvOGRLineString.h"
#include "FvOGRPolygon.h"
#include "FvOGRMultiPolygon.h"
#include "FvOGRMultiPoint.h"
#include "InternalObjectRegistry.h"
#include "ComErrorObject.h"
#include <curl.h>
#include "FvOGRGeometryCollection.h"
#include "..\geo_tool\geo_tool.h"

// CUtilityMethods

/*static*/ OGRLocalPointDriver* CUtilityMethods::s_OGRLocalPointDriver = NULL;
/*static*/ OGRDrawingDriver* CUtilityMethods::s_OGRDrawingDriver = NULL;

/*static*/ std::string CUtilityMethods::GDALErrors;

/*static*/ void CPL_STDCALL CUtilityMethods::GDALErrorHandler(CPLErr eErrClass, int err_no, const char *msg)
{
   switch (eErrClass)
   { // TODO
   case CE_None:
      GDALErrors.append("CE_None: ");
      break;
   case CE_Debug:
      GDALErrors.append("CE_Debug: ");
      break;
   case CE_Warning:
      GDALErrors.append("CE_Warning: ");
      break;
   case CE_Failure:
      GDALErrors.append("CE_Failure: ");
      break;
   case CE_Fatal:
      GDALErrors.append("CE_Fatal: ");
      break;
   default:
      GDALErrors.append("Unknown error class: ");
      break;
   }
   //sGDALErrors.append(err_no);
   GDALErrors.append(msg);
   //GDALErrors.append("\r\n");
}

/*static*/ void CUtilityMethods::WriteGDALErrorsToFVErrorLog()
{
   WriteStringToFVErrorLog(GDALErrors);
   GDALErrors = ""; // clear error string
}

/*static*/ void CUtilityMethods::WriteStringToFVErrorLog(std::string& s)
{
   std::wstring ws(s.begin(), s.end());
   WriteToLogFile(ws.c_str());
}

/*static*/ void CUtilityMethods::WriteStringToGeodataTraceLog(std::string& s)
{
   std::wstring ws(s.begin(), s.end());
   WriteToLogFile(ws.c_str(), L"GeodataTrace.log");
}

/*static*/ BOOL CUtilityMethods::s_bGDALInitialized = FALSE;

/*static*/ void CUtilityMethods::WrapGeometry(OGRGeometry* OGR_geometry, IGeometry** geometry)
{
   // this method expects that it will own the passed in OGR_geometry because the classes that it wraps it in
   // will delete the geometry when they clean up

   IGeometryPtr geometry_to_return;

   OGRwkbGeometryType type = OGR_geometry->getGeometryType();
   switch (type)
   {
   case wkbPoint:
   case wkbPoint25D:
      {
         IFvOGRPointPtr Fv_OGR_point = IFvOGRPointPtr(CLSID_FvOGRPoint);
         CFvOGRPoint* Fv_OGR_point_in_proc = (CFvOGRPoint*)CInternalObjectRegistry::GetObject(Fv_OGR_point->GetHandle());
         Fv_OGR_point_in_proc->AssociateWithOGRPoint((OGRPoint*)OGR_geometry);
         geometry_to_return = Fv_OGR_point;
      }
      break;
   case wkbLineString:
      {
         IFvOGRLineStringPtr Fv_OGR_line_string = IFvOGRLineStringPtr(CLSID_FvOGRLineString);
         CFvOGRLineString* Fv_OGR_line_string_in_proc = (CFvOGRLineString*)CInternalObjectRegistry::GetObject(Fv_OGR_line_string->GetHandle());
         Fv_OGR_line_string_in_proc->AssociateWithOGRLineString((OGRLineString*)OGR_geometry);
         geometry_to_return = Fv_OGR_line_string;
      }
      break;
   case wkbPolygon:
      {
         IFvOGRPolygonPtr Fv_OGR_polygon = IFvOGRPolygonPtr(CLSID_FvOGRPolygon);
         CFvOGRPolygon* Fv_OGR_polygon_in_proc = (CFvOGRPolygon*)CInternalObjectRegistry::GetObject(Fv_OGR_polygon->GetHandle());
         Fv_OGR_polygon_in_proc->AssociateWithOGRPolygon((OGRPolygon*)OGR_geometry);
         geometry_to_return = Fv_OGR_polygon;
      }
      break;
   case wkbMultiPolygon:
      {
         IFvOGRMultiPolygonPtr Fv_OGR_multi_polygon = IFvOGRMultiPolygonPtr(CLSID_FvOGRMultiPolygon);
         CFvOGRMultiPolygon* Fv_OGR_multi_polygon_in_proc = (CFvOGRMultiPolygon*)CInternalObjectRegistry::GetObject(Fv_OGR_multi_polygon->GetHandle());
         Fv_OGR_multi_polygon_in_proc->AssociateWithOGRMultiPolygon((OGRMultiPolygon*)OGR_geometry);
         geometry_to_return = Fv_OGR_multi_polygon;
      }
      break;
   case wkbMultiPoint:
   case wkbMultiPoint25D:
      {
         IFvOGRMultiPointPtr Fv_OGR_multi_point = IFvOGRMultiPointPtr(CLSID_FvOGRMultiPoint);
         CFvOGRMultiPoint* Fv_OGR_multi_point_in_proc = (CFvOGRMultiPoint*)CInternalObjectRegistry::GetObject(Fv_OGR_multi_point->GetHandle());
         Fv_OGR_multi_point_in_proc->AssociateWithOGRMultiPoint((OGRMultiPoint*)OGR_geometry);
         geometry_to_return = Fv_OGR_multi_point;
      }
      break;
   case wkbGeometryCollection:
      {
         IFvOGRGeometryCollectionPtr Fv_OGR_geometry_collection = IFvOGRGeometryCollectionPtr(CLSID_FvOGRGeometryCollection);
         CFvOGRGeometryCollection* Fv_OGR_geometry_collection_in_proc = (CFvOGRGeometryCollection*)CInternalObjectRegistry::GetObject(Fv_OGR_geometry_collection->GetHandle());
         Fv_OGR_geometry_collection_in_proc->AssociateWithOGRGeometryCollection((OGRGeometryCollection*)OGR_geometry);
         geometry_to_return = Fv_OGR_geometry_collection;
      }
      break;
   default:
      THROW_ERROR_MSG2(E_FAIL, "unsupported geometry type");
   }

   *geometry = geometry_to_return.Detach();
}

//STDMETHODIMP CUtilityMethods::raw_CheckShapefile(BSTR path, VARIANT_BOOL* valid)
//{
//   TRY_BLOCK
//   {
//      _bstr_t _path = _bstr_t(path);
//      OGRDataSource* poDS = OGRSFDriverRegistrar::Open((char *)_path, FALSE);
//      if(poDS == NULL)
//         return E_FAIL;
//      OGRSFDriver* driver = poDS->GetDriver();
//      const char* driver_name = driver->GetName();
//      *valid = !strcmp(driver_name, "ESRI Shapefile") ? VARIANT_TRUE : VARIANT_FALSE;
//   }
//   CATCH_BLOCK_RET
//
//   return S_OK;
//}
//
//STDMETHODIMP CUtilityMethods::raw_CopyShapefile(BSTR from, BSTR to)
//{
//   // TODO: get .prj file to work (maybe set SR on output?)
//   return CopyShapefileTo(from, to, _bstr_t("ESRI Shapefile"));
//}
//
//STDMETHODIMP CUtilityMethods::raw_CopyShapefileToKML(BSTR from, BSTR to)
//{
//   return CopyShapefileTo(from, to, _bstr_t("KML"));
//}
//
//STDMETHODIMP CUtilityMethods::raw_CopyShapefileTo(BSTR from, BSTR to, BSTR driver)
//{
//   return CopyTo(from, to, driver);
//}
//
//STDMETHODIMP CUtilityMethods::raw_CopyKMLTo(BSTR from, BSTR to, BSTR driver)
//{
//   return CopyTo(from, to, driver);
//}
//
//STDMETHODIMP CUtilityMethods::raw_CopyTo(BSTR from, BSTR to, BSTR driver)
//{
//   TRY_BLOCK
//   {
//      std::string _from((char*)_bstr_t(from));
//      std::string _to((char*)_bstr_t(to));
//
//      // open the input Shapefile and layer
//
//      OGRDataSource* poDS_in = OGRSFDriverRegistrar::Open(_from.c_str(), FALSE);
//      if(poDS_in == NULL)
//         THROW_ERROR_MSG2(E_FAIL, "OGRSFDriverRegistrar::Opentype failed");
//
//      OGRLayer* poLayer_in = poDS_in->GetLayer(0);
//      if(poLayer_in == NULL)
//         THROW_ERROR_MSG2(E_FAIL, "GetLayer failed");
//
//      // create the output Shapefile driver
//
//      OGRSFDriver* poDriver_out = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName((char*)_bstr_t(driver));
//      if(poDriver_out == NULL)
//         THROW_ERROR_MSG2(E_FAIL, "GetDriverByName failed");
//
//      // create the output datasource
//
//      OGRDataSource* poDS_out= poDriver_out->CreateDataSource(_to.c_str(), NULL);
//      if(poDS_out == NULL)
//         THROW_ERROR_MSG2(E_FAIL, "CreateDataSource failed");
//
//      // create the output layer
//
//      size_t layer_name_start = _from.find_last_of("\\", std::string.npos) + 1;
//      size_t layer_name_end = _from.find_last_of(".", std::string.npos);
//      std::string layer_name = _from.substr(layer_name_start, layer_name_end - layer_name_start);
//
//      OGRLayer* poLayer_out = poDS_out->CreateLayer(layer_name.c_str(), NULL, wkbPoint, NULL); // TODO: support different WKB types
//      if(poLayer_out == NULL)
//         THROW_ERROR_MSG2(E_FAIL, "CreateLayer failed");
//
//      // create the fields on the output layer
//
//      OGRFeatureDefn *poFDefn = poLayer_in->GetLayerDefn();
//
//      for(int iField = 0; iField < poFDefn->GetFieldCount(); iField++)
//      {
//         OGRFieldDefn* poFieldDefn = poFDefn->GetFieldDefn(iField);
//         if(poLayer_out->CreateField(poFieldDefn) != OGRERR_NONE)
//            THROW_ERROR_MSG2(E_FAIL, "CreateField failed");
//      }
//
//      // copy feature by feature
//
//      OGRFeature* poFeature;
//      poLayer_in->ResetReading();
//
//      while((poFeature = poLayer_in->GetNextFeature()) != NULL)
//      {
//         if(poLayer_out->CreateFeature(poFeature) != OGRERR_NONE)
//            THROW_ERROR_MSG2(E_FAIL, "CreateFeature failed");
//         OGRFeature::DestroyFeature(poFeature);
//      }
//
//      // clean up
//
//      OGRDataSource::DestroyDataSource(poDS_in);
//      OGRDataSource::DestroyDataSource(poDS_out);
//   }
//   CATCH_BLOCK_RET
//
//   return S_OK;
//}
//
//STDMETHODIMP CUtilityMethods::raw_CheckKML(BSTR path, VARIANT_BOOL* valid)
//{
//   TRY_BLOCK
//   {
//      _bstr_t _path = _bstr_t(path);
//      OGRDataSource* poDS = OGRSFDriverRegistrar::Open((char *)_path, FALSE);
//      if(poDS == NULL)
//         return E_FAIL;
//      OGRSFDriver* driver = poDS->GetDriver();
//      const char* driver_name = driver->GetName();
//      *valid = !strcmp(driver_name, "KML") ? VARIANT_TRUE : VARIANT_FALSE;
//   }
//   CATCH_BLOCK_RET
//
//   return S_OK;
//}

//
// CURL Stuff
//

// CURLOPT_WRITEFUNCTION:
// size*nmemb bytes of data are at ptr, stream is user data
// return must be size*nmemb or curl itself will fail.
static size_t FetchToString(void* ptr, size_t size, size_t nmemb, void* user) {
   // static function, only user is DoCurlToString which uses CURLOPT_WRITEDATA
   // to set the "user" arg which is the C++ string (buffer) to write to.
   size_t nbytes = size * nmemb;
   std::string *output_buffer = reinterpret_cast<std::string*>(user);
   output_buffer->append(reinterpret_cast<char*>(ptr), nbytes);
   return nbytes;
}

// Separate worker function to simplify bool return logic.
static bool DoCurlToString(CURL* curl, const char* url, std::string* data, const char* user_name = NULL, const char* password = NULL)
{
   CURLcode code;

   do // break on error
   {
      code = curl_easy_setopt(curl, CURLOPT_URL, url);
      if (code != CURLE_OK)
         break;

      code = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, FetchToString);
      if (code != CURLE_OK)
         break;

      code = curl_easy_setopt(curl, CURLOPT_WRITEDATA, reinterpret_cast<void*>(data));
      if (code != CURLE_OK)
         break;

      code = curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
      if (code != CURLE_OK)
         break;

      // NOTE: CA not verified for SSL (need DoD keys)
      // TODO: allow installation of keys, etc...
      code = curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
      if (code != CURLE_OK)
         break;

      // set up authentication, if we have a user name and password
      char* user_name_and_password = NULL;
      if (user_name && password)
      {
         code = curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
         if (code != CURLE_OK)
            break;

         size_t size = strlen(user_name) + strlen(password) + 2;
         user_name_and_password = new char[size];
         sprintf_s(user_name_and_password, size, "%s:%s", user_name, password);

         code = curl_easy_setopt(curl, CURLOPT_USERPWD, user_name_and_password);
         if (code != CURLE_OK)
            break;
      }

      code = curl_easy_perform(curl);
      if (user_name_and_password)
         delete[] user_name_and_password;
      if (code != CURLE_OK)
         break;

      return true;
   }
   while (false);

   // if we get here, there has been an error

   const size_t BUF_SIZE = 100;
   char buf[BUF_SIZE];
   sprintf_s(buf, BUF_SIZE, "%x", code);

   std::string msg("curl error: 0x");
   msg.append(buf);
   msg.append(" / ");
   msg.append(curl_easy_strerror(code)); // leak?? online examples don't delete returned char*

   CUtilityMethods::WriteStringToFVErrorLog(msg);

   return false;
}

// Wrapper to manage curl handle.  Very simple stateless implementation.  Less
// simplistic would be to reuse the CURL* handle between invocations.
bool CurlToString(const char* url, std::string* data, const char* user_name /* = NULL */, const char* password /* = NULL */) {
   CURL* curl = curl_easy_init();
   bool ret = DoCurlToString(curl, url, data, user_name, password);
   curl_easy_cleanup(curl);
   return ret;
}

//
// End of curl stuff
//

/* static */ std::string CUtilityMethods::ResolveURI(const char* base_url, const char* uri)
{
   // call from within a TRY_BLOCK

   // base_url may be a file name, a URL, etc.
   //  Examples:
   //    C:\Documents and Settings\User\Desktop\KML Test Data\Screen Overlays.kml
   //    http://paris.thover.com/images/blog/tdf/2009/tdf2009.kml
   //    NULL (in which case this just returns uri)

   // uri is an item to fetch from the same location as base_url (if the location is already fully-qualified, it just returns the original location)
   //  Examples:
   //    homer-simpson-elvis.gif
   //    http://paris.thover.com/images/tdf.gif

   // if base_url is NULL, just return uri
   if (!base_url)
   {
      std::string resolved(uri);
      return resolved;
   }

   // escape the URL so that it is compatible with ResolveUri (ResolveUri likes some characters and doesn't like others)

   char* escaped = curl_escape(base_url, 0);
   size_t s = strlen(escaped);
   char* partially_escaped = new char[s + 1]; // probably extra bytes after buffer because escape sequences converted back to single characters
   char* f = escaped; // f is the current position in the fully escaped string (reading from)
   char* p = partially_escaped; // p is the current position in the partially escaped string (writing to)

   while (f <= escaped + s) // <= to copy the terminating null
   {
      if (!memcmp(f, "%3A", 3)) // %3A -> :
      {
         *(p++) = ':';
         f += 3;
      }
      else if (!memcmp(f, "%5C", 3)) // %5C -> /  (note that 0x5c is really a backslash)
      {
         *(p++) = '/';
         f += 3;
      }
      else if (!memcmp(f, "%2E", 3)) // %2E -> .
      {
         *(p++) = '.';
         f += 3;
      }
      else if (!memcmp(f, "%2F", 3)) // %2F -> /
      {
         *(p++) = '/';
         f += 3;
      }
      else // copy as-is
         *(p++) = *(f++);
   }

   curl_free(escaped);

   // resolve the full URL of the image file name from the base URL and the image file name (identifier)
   std::string result;
   if (!kmlengine::ResolveUri(partially_escaped, uri, &result))
      result = uri; // failures may happen on fully-qualified local paths, which are okay as they are
   delete[] partially_escaped;
   char* unescaped = curl_unescape(result.c_str(), 0); // at this point, unescaped holds the resolved URL to the image
   std::string resolved(unescaped);
   curl_free(unescaped);
   return resolved;
}

/* static */
void CUtilityMethods::Create32BppBitmap(VARIANT* imageData, int x_size, int y_size)
{
   // initialize the return array
   SAFEARRAYBOUND saBound;
   saBound.cElements = 40 + 4*x_size*y_size; // 40 bytes for the header plus 32 bits per image pixel
   saBound.lLbound = 0;
   VariantInit(imageData);
   imageData->vt = VT_ARRAY | VT_I1;
   imageData->parray = SafeArrayCreate(VT_I1, 1, &saBound);
   UCHAR* pos = NULL;
   SafeArrayAccessData(imageData->parray, reinterpret_cast<void **>(&pos));

   // populate the bitmap header
   pos[4] = x_size % 256; // 4 & 5 hold width
   pos[5] = (int)(x_size / 256);
   pos[8] = y_size % 256; // 8 & 9 hold height
   pos[9] = (int)(y_size / 256);
   pos[14] = 32; // 32 bits per pixel (BGRA)

   SafeArrayUnaccessData(imageData->parray);
}

/* static */ void CUtilityMethods::ReplaceAllInString(std::string& subject, const char* find, const char* replacement)
{
   if (!strcmp(find, replacement))
      return;
   size_t find_length = strlen(find);
   std::string::size_type position = subject.find(find);
   while (position != subject.npos)
   {
      subject.replace(position, find_length, replacement);
      position = subject.find(find);
   }
}

/* static */ bool CUtilityMethods::LooksLikeHttp(const char* s, bool https /* = false */)
{
   return strlen(s) > (https ? (size_t)8 : (size_t)7) // longer than "http(s)://"
      && ::tolower(s[0]) == 'h'
      && ::tolower(s[1]) == 't'
      && ::tolower(s[2]) == 't'
      && ::tolower(s[3]) == 'p'
      && (!https || ::tolower(s[4]) == 's');
}

/* static */ bool CUtilityMethods::LooksLikeRoot(const char* s)
{
   return strlen(s) > 5 // longer than "root:"
      && ::tolower(s[0]) == 'r'
      && ::tolower(s[1]) == 'o'
      && ::tolower(s[2]) == 'o'
      && ::tolower(s[3]) == 't'
      && s[4] == ':';
}

STDMETHODIMP CUtilityMethods::raw_GetLeakData(VARIANT* leakData)
{
   VariantInit(leakData);
   leakData->vt = VT_UINT;
   leakData->uintVal = (UINT)CInternalObjectRegistry::ObjectCount();
   return S_OK;
}

/*static*/ BOOL CUtilityMethods::FeatureInFilter(IFeature* feature, IFilter* filter, std::string& error_message)
{
   if (filter == NULL)
      return TRUE; // NULL filters mean no filtering at all

   // we currently only support geometry filters
   IGeometryFilterPtr geometryFilter = filter;
   if (!geometryFilter)
   {
      error_message = "unsupported filter type - currently only support geometry filters";
      return FALSE;
   }

   // the filter's geometry must support spatial relations
   ISpatialRelationPtr spatialRelation = geometryFilter->Geometry;
   if (!spatialRelation)
   {
      error_message = "filter geometry must support spatial relations";
      return FALSE;
   }

   return spatialRelation->Intersects(feature->Geometry);
}

/*static*/ void CUtilityMethods::GetRectangularFilterBounds(IFilter* filter, double* minX, double* minY, double* maxX, double* maxY)
{
   // This should be called from within a TRY_BLOCK.  Filter must be a rectangular filter that meets the criteria below.

   IGeometryFilterPtr geometryFilter = filter;
   if (!geometryFilter)
      THROW_ERROR_MSG2(E_FAIL, "filter must be geometry filter");

   IPolygonPtr polygon = geometryFilter->Geometry;
   if (!polygon)
      THROW_ERROR_MSG2(E_FAIL, "filter geometry must be a polygon");

   if (polygon->NumInteriorRings != 0)
      THROW_ERROR_MSG2(E_FAIL, "filter polygon must have zero interior rings");

   ILinearRingPtr exteriorRing = polygon->ExteriorRing();
   if (exteriorRing->NumPoints != 5)//closed rings with four corners have the initial point repeated (5 points)
      THROW_ERROR_MSG2(E_FAIL, "filter polygon must have four corners");
   if (!exteriorRing->IsClosed)
      THROW_ERROR_MSG2(E_FAIL, "filter polygon must be closed");

   geometryFilter->Extent2D(minX, minY, maxX, maxY);

   if (*minX > *maxX || *minY > *maxY)
   {
      // date line crossings should be handled by adjusting bounds by 360
      THROW_ERROR_MSG2(E_FAIL, "filter maximums and minimums must be proper");
   }

   for (int index = 0; index < 4; index++)
   {
      // ensure that we are dealing with a rectangle
      IPointPtr point = exteriorRing->Point(index);
      if ( (point->x != *minX && point->x != *maxX) || (point->y != *minY && point->y != *maxY) )
         THROW_ERROR_MSG2(E_FAIL, "filter polygon must be a rectangle");
   }

   if(*minX == *maxX)
   {
      //we wrap around the world
      *minX = -180;
      *maxX = 180;
   }
}

/* static */ void CUtilityMethods::ShiftXWindowWithinM180To360(double* minX, double* maxX)
{
   // bring the min x bounds within -180 to 180
   while (*minX < -180.0)
      *minX += 360.0;
   while (*minX > 180.0)
      *minX -= 360.0;

   // bring the max x bounds within -180 to 360 (360 allows date line crossing)
   while (*maxX < -180.0)
      *maxX += 360.0;
   while (*maxX > 360.0)
      *maxX -= 360.0;

   // make sure that max >= min
   while (*minX > *maxX)
      *maxX += 360.0;
}

/* static */ bool CUtilityMethods::RectanglesInRectangle(
   DOUBLE minX, DOUBLE minY, DOUBLE maxX, DOUBLE maxY,
   DOUBLE leftLon, DOUBLE bottomLat, DOUBLE rightLon, DOUBLE topLat)
{
   return GEO_intersect(minY, minX, maxY, maxX,
                        bottomLat, leftLon, topLat, rightLon) == TRUE;
}

/* static */ bool CUtilityMethods::KMLFeatureInRectangle(
   kmldom::FeaturePtr feature, DOUBLE leftLon, DOUBLE bottomLat, DOUBLE rightLon, DOUBLE topLat)
{
   kmlengine::Bbox bbox;

   if (kmlengine::GetFeatureBounds(feature, &bbox)) // features with no defined bbox are included
   {
      double minX = bbox.get_west();
      double minY = bbox.get_south();
      double maxX = bbox.get_east();
      double maxY = bbox.get_north();

      while (rightLon > 180.0)
         rightLon -= 180.0;

      return RectanglesInRectangle(minX, minY, maxX, maxY, leftLon, bottomLat, rightLon, topLat);
   }

   return true;
}

/* static */ kmldom::ElementPtr CUtilityMethods::GetAncestorOfType(const kmldom::ElementPtr& element, kmldom::KmlDomType type)
{
   kmldom::ElementPtr ret = element->GetParent();
   while(ret != NULL && !ret->IsA(type))
      ret = ret->GetParent();

   return ret;
}

/* static */ bool CUtilityMethods::KMLFeatureInRegion(kmldom::FeaturePtr feature,
   DOUBLE leftLon, DOUBLE bottomLat, DOUBLE rightLon, DOUBLE topLat,
   DOUBLE degreesPerPixelX, DOUBLE degreesPerPixelY)  // use negative number if dpp is not set)
{
   // If the given feature does not have a region, then find the youngest
   // ancestor that does
   while (feature != NULL && feature->has_region() == false)
      feature = kmldom::AsFeature(GetAncestorOfType(feature, kmldom::Type_Feature));

   if (feature != NULL && feature->has_region())
   {
      kmldom::RegionPtr region = feature->get_region();

      if (region->has_latlonaltbox()) // required per spec, but we'll be nice...
      {
         // return false if the <LatLonAltBox> is not in view

         kmldom::LatLonAltBoxPtr bbox = region->get_latlonaltbox();

         double minX = bbox->get_west();
         double minY = bbox->get_south();
         double maxX = bbox->get_east();
         double maxY = bbox->get_north();

         if (!RectanglesInRectangle(minX, minY, maxX, maxY, leftLon, bottomLat, rightLon, topLat))
            return false;

         // return false if the <Lod> requirements aren't met

         if (region->has_lod())
         {
            kmldom::LodPtr lod = region->get_lod();

            // compute the square root of the area, in square pixels, of the 
            // region projected onto the surface
            double regionAreaPixels = sqrt(((maxX - minX) / degreesPerPixelX) 
               * ((maxY - minY) / degreesPerPixelY));

            // test <minLodPixels>
            if (lod->has_minlodpixels())
            {
               double minLodPixels = lod->get_minlodpixels();
               if (regionAreaPixels < minLodPixels)
                  return false;
            }

            // test <maxLodPixels>
            if (lod->has_maxlodpixels())
            {
               double maxLodPixels = lod->get_maxlodpixels();
               if (maxLodPixels > 0) // -1 means active to infinite size on screen
               {
                  if (regionAreaPixels > maxLodPixels)
                     return false;
               }
            }
         }
      }
   }

   return true; // returns true if no region, or region is active
}


//
// Geometry copy functions (OGR)
//

/*static*/ OGRPoint* CUtilityMethods::Copy2OGR(IPoint* point)
{
   OGRPoint *ogrPoint = new OGRPoint;
   ogrPoint->setX(point->x);
   ogrPoint->setY(point->y);
   return ogrPoint;
}

/*static*/ OGRLineString* CUtilityMethods::Copy2OGR(ILineString* lineString)
{
   OGRLineString *ogrLineString = new OGRLineString;
   for( long i = 0 ; i < lineString->GetNumPoints() ; i++)
   {
      OGRPoint *geo = Copy2OGR(lineString->Point(i));
      ogrLineString->addPoint(geo);
      delete geo;
   }
   return ogrLineString;
}

/*static*/ OGRLinearRing* CUtilityMethods::Copy2OGR(ILinearRing* linearRing)
{
   OGRLinearRing *ogrLinearRing = new OGRLinearRing;
   for( long i = 0 ; i < linearRing->GetNumPoints() ; i++)
   {
      OGRPoint *geo = Copy2OGR(linearRing->Point(i));
      ogrLinearRing->addPoint(geo);
      delete geo;
   }
   return ogrLinearRing;
}

/*static*/ OGRPolygon* CUtilityMethods::Copy2OGR(IPolygon* polygon)
{
   OGRPolygon *ogrPolygon = new OGRPolygon;

   OGRLinearRing *geo = Copy2OGR(polygon->ExteriorRing());
   ogrPolygon->addRing(geo);
   delete geo;

   for( long i = 0 ; i < polygon->GetNumInteriorRings() ; i++)
   {
      geo = Copy2OGR(polygon->InteriorRing(i));
      ogrPolygon->addRing(geo);
      delete geo;
   }

   return ogrPolygon;
}

/*static*/ OGRGeometryCollection* CUtilityMethods::Copy2OGR(IGeometryCollection* collection)
{
   OGRGeometryCollection *ogrCollection = new OGRGeometryCollection;

   for( long i = 0 ; i < collection->GetNumGeometries() ; i ++)
   {
      OGRGeometry* geo = CopyGeometry2OGR(collection->Geometry(i));
      ogrCollection->addGeometry(geo);
      delete geo;
   }
   return ogrCollection;
}

/*static*/ OGRGeometry* CUtilityMethods::CopyGeometry2OGR(IGeometry* featureGeometry)
{
   //we check for type and call the overloaded Copy methods

   IPointPtr point = featureGeometry;
   if (point)
      return Copy2OGR(point);

   ILineStringPtr lineString = featureGeometry;
   if (lineString)
      return Copy2OGR(lineString);

   ILinearRingPtr linearRing = featureGeometry;
   if (linearRing)
      return Copy2OGR(linearRing);

   IPolygonPtr polygon = featureGeometry;
   if (polygon)
      return Copy2OGR(polygon);

   IGeometryCollectionPtr geometryCollection = featureGeometry;
   if (geometryCollection)
      return Copy2OGR(geometryCollection);

   THROW_ERROR_MSG2(E_FAIL, "unsupported geometry type");
}

//
// End of Geometry copy functions (OGR)
//

/* static */ bool CUtilityMethods::ParseKMLDateTime(const std::string& sDateTime, COleDateTime& dtOut, std::string& error) // returns UTC
{
   //
   // From http://code.google.com/apis/kml/documentation/kmlreference.html#timespan
   //
   // Specifies a single moment in time. The value is a dateTime, which can be one of the following:
   // dateTime gives second resolution
   // date gives day resolution
   // gYearMonth gives month resolution
   // gYear gives year resolution
   // The following examples show different resolutions for the <when> value:
   // gYear (YYYY)
   // <TimeStamp>
   //   <when>1997</when>
   // </TimeStamp>
   // gYearMonth (YYYY-MM)
   // <TimeStamp>
   //   <when>1997-07</when>
   // </TimeStamp> 
   // date (YYYY-MM-DD)
   // <TimeStamp>
   //   <when>1997-07-16</when>
   // </TimeStamp> 
   // dateTime (YYYY-MM-DDThh:mm:ssZ)
   // Here, T is the separator between the calendar and the hourly notation of time, and Z indicates UTC. (Seconds are required.)
   // <TimeStamp>
   //   <when>1997-07-16T07:30:15Z</when>
   // </TimeStamp>
   // dateTime (YYYY-MM-DDThh:mm:sszzzzzz)
   // This example gives the local time and then the ± conversion to UTC.
   // <TimeStamp>
   //   <when>1997-07-16T10:30:15+03:00</when>
   // </TimeStamp>
   //

   size_t len = sDateTime.length();

   if (len < 4)
   {
      error = "datetime length too short";
      return false;
   }

   // parse year
   std::string sYear = sDateTime.substr(0, 4);
   int year = atoi(sYear.c_str());
   if (year < 100 || year > 9999) // http://msdn.microsoft.com/en-us/library/38wh24td.aspx
   {
      error = "invalid year";
      return false;
   }

   // parse month
   int month = 1;
   if (len > 4)
   {
      if (len < 7)
      {
         error = "datetime length should not be 5 or 6";
         return false;
      }

      std::string sMonth = sDateTime.substr(5, 2);
      month = atoi(sMonth.c_str());
      if (month < 1 || month > 12)
      {
         error = "invalid month";
         return false;
      }
   }

   // parse day
   int day = 1;
   if (len > 7)
   {
      if (len < 10)
      {
         error = "datetime length should not be 8 or 9";
         return false;
      }

      std::string sDay = sDateTime.substr(8, 2);
      day = atoi(sDay.c_str());
      if (day < 1 || day > 31)
      {
         error = "invalid day";
         return false;
      }
   }

   // parse hour, minute, second and time zone offset
   int hour = 0;
   int minute = 0;
   int second = 0;
   if (len > 10)
   {
      if (len != 19 && len != 20 && len != 25) // we allow a length of 19 to allow for times that omit the Z for Zulu
      {
         error = "invalid datetime";
         return false;
      }

      std::string sHour = sDateTime.substr(11, 2);
      hour = atoi(sHour.c_str());
      if (hour < 0 || hour > 23)
      {
         error = "invalid hour";
         return false;
      }

      std::string sMinute = sDateTime.substr(14, 2);
      minute = atoi(sMinute.c_str());
      if (minute < 0 || minute > 59)
      {
         error = "invalid minute";
         return false;
      }

      std::string sSecond = sDateTime.substr(17, 2);
      second = atoi(sSecond.c_str());
      if (second < 0 || second > 59)
      {
         error = "invalid second";
         return false;
      }

      if (len == 25) // zone offset, not Zulu
      {
         std::string sOffsetHours = sDateTime.substr(20, 2);
         int offsetHours = atoi(sOffsetHours.c_str());
         if (offsetHours < 0 || offsetHours > 13)
         {
            error = "invalid offset hours";
            return false;
         }

         std::string sOffsetMinutes = sDateTime.substr(22, 2);
         int offsetMinutes = atoi(sOffsetMinutes.c_str());
         if (offsetMinutes < 0 || offsetMinutes > 59)
         {
            error = "invalid offset minutes";
            return false;
         }

         // apply offset and return
         COleDateTimeSpan offset(0, offsetHours, offsetMinutes, 0);
         dtOut.SetDateTime(year, month, day, hour, minute, second);
         if (sDateTime[19] == '-')
            dtOut -= offset;
         else
            dtOut += offset;
         return true;
      }
   }

   dtOut.SetDateTime(year, month, day, hour, minute, second); // UTC
   return true;
}

/* static */ bool CUtilityMethods::KMLTimePrimitiveInTemporalFilter(kmldom::TimePrimitivePtr time_primitive, ITemporalFilter* temporal_filter)
{
   // call within TRY_BLOCK for error handling purposes

   // get the begining and ending as strings

   std::string sBegin, sEnd; // "" indicates unbounded

   kmldom::TimeSpanPtr time_span = kmldom::AsTimeSpan(time_primitive);
   if (time_span)
   {
      if (time_span->has_begin())
         sBegin = time_span->get_begin();
      if (time_span->has_end())
         sEnd = time_span->get_end();
   }

   kmldom::TimeStampPtr time_stamp = kmldom::AsTimeStamp(time_primitive);
   if (time_stamp)
   {
      if (time_stamp->has_when())
         sBegin = sEnd = time_stamp->get_when();
   }

   // return false if we are before the begin date
   std::string error;
   if (sBegin.length() > 0)
   {
      COleDateTime dtBegin;
      if (!ParseKMLDateTime(sBegin, dtBegin, error))
      {
         std::string msg("Could not parse time in KML (");
         msg.append(error);
         msg.append("): ");
         msg.append(sBegin);
         const size_t MAX_LENGTH = 250;
         if (msg.size() > MAX_LENGTH)
            msg = msg.substr(0, MAX_LENGTH);
         THROW_ERROR_MSG2(E_FAIL, msg.c_str());
      }

      COleDateTime filterEnd(temporal_filter->End);
      if (filterEnd < dtBegin)
         return false;
   }

   // return false if we are after the end date
   if (temporal_filter->Start == temporal_filter->End && time_stamp)
   {
      // SPECIAL CASE: If we have a KML time stamp and the temporal filter is a single moment in time, we ignore the end date, which
      // essentially makes us capture any event before the end date.
   }
   else
   {
      if (sEnd.length() > 0)
      {
         COleDateTime dtEnd;
         if (!ParseKMLDateTime(sEnd, dtEnd, error))
         {
            std::string msg("Could not parse time in KML (");
            msg.append(error);
            msg.append("): ");
            msg.append(sEnd);
            const size_t MAX_LENGTH = 250;
            if (msg.size() > MAX_LENGTH)
               msg = msg.substr(0, MAX_LENGTH);
            THROW_ERROR_MSG2(E_FAIL, msg.c_str());
         }

         COleDateTime filterStart(temporal_filter->Start);
         if (filterStart > dtEnd)
            return false;
      }
   }

   return true; // time spans intersect
}

/* static */ bool CUtilityMethods::KMLTimePrimitiveHasStart(kmldom::TimePrimitivePtr time_primitive)
{
   kmldom::TimeSpanPtr time_span = kmldom::AsTimeSpan(time_primitive);
   if (time_span)
      return time_span->has_begin();

   kmldom::TimeStampPtr time_stamp = kmldom::AsTimeStamp(time_primitive);
   if (time_stamp)
      return time_stamp->has_when();

   return false;
}

/* static */ DATE CUtilityMethods::KMLTimePrimitiveStart(kmldom::TimePrimitivePtr time_primitive)
{
   // call from within a TRY_BLOCK

   kmldom::TimeSpanPtr time_span = kmldom::AsTimeSpan(time_primitive);
   if (time_span)
   {
      if (time_span->has_begin())
      {
         COleDateTime dtStart;
         std::string error;

         if (!CUtilityMethods::ParseKMLDateTime(time_span->get_begin(), dtStart, error))
         {
            const size_t MAX_LENGTH = 250;
            if (error.size() > MAX_LENGTH)
               error = error.substr(0, MAX_LENGTH);
            THROW_ERROR_MSG2(E_FAIL, error.c_str());
         }

         return (DATE)dtStart;
      }
   }

   kmldom::TimeStampPtr time_stamp = kmldom::AsTimeStamp(time_primitive);
   if (time_stamp)
   {
      if (time_stamp->has_when())
      {
         COleDateTime dtStart;
         std::string error;

         if (!CUtilityMethods::ParseKMLDateTime(time_stamp->get_when(), dtStart, error))
         {
            const size_t MAX_LENGTH = 250;
            if (error.size() > MAX_LENGTH)
               error = error.substr(0, MAX_LENGTH);
            THROW_ERROR_MSG2(E_FAIL, error.c_str());
         }

         return (DATE)dtStart;
      }
   }

   THROW_ERROR_MSG2(E_FAIL, "could not find a start time");
}

/* static */ bool CUtilityMethods::KMLTimePrimitiveHasEnd(kmldom::TimePrimitivePtr time_primitive)
{
   kmldom::TimeSpanPtr time_span = kmldom::AsTimeSpan(time_primitive);
   if (time_span)
      return time_span->has_end();

   kmldom::TimeStampPtr time_stamp = kmldom::AsTimeStamp(time_primitive);
   if (time_stamp)
      return time_stamp->has_when();

   return false;
}

/* static */ DATE CUtilityMethods::KMLTimePrimitiveEnd(kmldom::TimePrimitivePtr time_primitive)
{
   // call from within a TRY_BLOCK

   kmldom::TimeSpanPtr time_span = kmldom::AsTimeSpan(time_primitive);
   if (time_span)
   {
      if (time_span->has_end())
      {
         COleDateTime dtEnd;
         std::string error;

         if (!CUtilityMethods::ParseKMLDateTime(time_span->get_end(), dtEnd, error))
         {
            const size_t MAX_LENGTH = 250;
            if (error.size() > MAX_LENGTH)
               error = error.substr(0, MAX_LENGTH);
            THROW_ERROR_MSG2(E_FAIL, error.c_str());
         }

         return (DATE)dtEnd;
      }
   }

   kmldom::TimeStampPtr time_stamp = kmldom::AsTimeStamp(time_primitive);
   if (time_stamp)
   {
      if (time_stamp->has_when())
      {
         COleDateTime dtEnd;
         std::string error;

         if (!CUtilityMethods::ParseKMLDateTime(time_stamp->get_when(), dtEnd, error))
         {
            const size_t MAX_LENGTH = 250;
            if (error.size() > MAX_LENGTH)
               error = error.substr(0, MAX_LENGTH);
            THROW_ERROR_MSG2(E_FAIL, error.c_str());
         }

         return (DATE)dtEnd;
      }
   }

   THROW_ERROR_MSG2(E_FAIL, "could not find an end time");
}

// methods to create WKT from geometries

/* static */ void CUtilityMethods::PointToWKT(IPoint* point, std::string& wkt)
{
   wkt = "Point(";
   AppendDoubleTupleToString(point->x, point->y, wkt);
   wkt.append(")");
}

/* static */ void CUtilityMethods::MultiPointToWKT(IGeometryCollection* multi_point, std::string& wkt)
{
   wkt = "MultiPoint(";
   long numGeometries = multi_point->NumGeometries;
   for (long i = 0; i < numGeometries; i++)
   {
      wkt.append("(");
      IPointPtr point = multi_point->Geometry(i);
      AppendDoubleTupleToString(point->x, point->y, wkt);
      if (i < numGeometries - 1)
         wkt.append("), ");
      else
         wkt.append("))");
   }
}

/* static */ void CUtilityMethods::LineStringToWKT(ILineString* line_string, std::string& wkt)
{
   wkt = "LineString";
   AppendLineStringToString(line_string, wkt);
}

/* static */ void CUtilityMethods::LinearRingToWKT(ILinearRing* linear_ring, std::string& wkt)
{
   wkt = "LinearRing"; // non-standard, but not uncommon
   AppendLineStringToString(linear_ring, wkt);
}

/* static */ void CUtilityMethods::PolygonToWKT(IPolygon* polygon, std::string& wkt)
{
   wkt = "Polygon";
   AppendPolygonToString(polygon, wkt);
}

/* static */ void CUtilityMethods::MultiPolygonToWKT(IGeometryCollection* multi_polygon, std::string& wkt)
{
   wkt = "MultiPolygon(";
   long numGeometries = multi_polygon->NumGeometries;
   for (long i = 0; i < numGeometries; i++)
   {
      IPolygonPtr polygon = multi_polygon->Geometry(i);
      AppendPolygonToString(polygon, wkt);
      if (i < numGeometries - 1)
         wkt.append(", ");
   }
   wkt.append(")");
}

/* static */ void CUtilityMethods::GeometryCollectionToWKT(IGeometryCollection* geometry_collection, std::string& wkt)
{
   wkt = "GeometryCollection(";
   long numGeometries = geometry_collection->NumGeometries;
   for (long i = 0; i < numGeometries; i++)
   {
      if (i > 0)
         wkt.append(", ");

      IGeometryPtr geometry = geometry_collection->Geometry(i);
      
      IPointPtr point = geometry;
      if (point)
      {
         PointToWKT(point, wkt);
         continue;
      }

      ILinearRingPtr linear_ring = geometry;
      if (linear_ring) // must test before line string
      {
         LinearRingToWKT(linear_ring, wkt);
         continue;
      }

      ILineStringPtr line_string = geometry;
      if (line_string)
      {
         LineStringToWKT(line_string, wkt);
         continue;
      }

      IPolygonPtr polygon = geometry;
      if (polygon)
      {
         PolygonToWKT(polygon, wkt);
         continue;
      }

      // Note the behavior here: this only identifies multi-point and multi-polygon if they are OGR

      IGeometryCollectionPtr geometry_collection = geometry;

      IFvOGRMultiPointPtr multi_point;
      if (multi_point) // must test before geometry collection
      {
         MultiPointToWKT(geometry_collection, wkt);
         continue;
      }

      IFvOGRMultiPolygonPtr multi_polygon;
      if (multi_point) // must test before geometry collection
      {
         MultiPolygonToWKT(geometry_collection, wkt);
         continue;
      }

      if (geometry_collection)
      {
         GeometryCollectionToWKT(geometry_collection, wkt);
         continue;
      }

      wkt.append("UNKNOWN_GEOMETRY");
   }
   wkt.append(")");
}

/* static */ void CUtilityMethods::AppendDoubleToString(double d, std::string& s)
{
   const int BUF_SIZE = 30;
   char buf[BUF_SIZE];
   sprintf_s(buf, BUF_SIZE, "%g", d);
   s.append(buf);
}

/* static */ void CUtilityMethods::AppendDoubleTupleToString(double d1, double d2, std::string& s)
{
   AppendDoubleToString(d1, s);
   s.append(" ");
   AppendDoubleToString(d2, s);
}

/* static */ void CUtilityMethods::AppendLineStringToString(ILineString* line_string, std::string& s)
{
   s.append("(");
   long numPoints = line_string->NumPoints;
   for (long i = 0; i < numPoints; i++)
   {
      IPointPtr point = line_string->Point(i);
      AppendDoubleTupleToString(point->x, point->y, s);
      if (i < numPoints - 1)
         s.append(", ");
   }
   s.append(")");
}

/* static */ void CUtilityMethods::AppendPolygonToString(IPolygon* polygon, std::string& s)
{
   s.append("(");
   AppendLineStringToString(polygon->ExteriorRing(), s);
   long numInteriorRings = polygon->NumInteriorRings;
   for (long i = 0; i < numInteriorRings; i++)
   {
      s.append(", ");
      AppendLineStringToString(polygon->InteriorRing(i), s);
   }
   s.append(")");
}