root/FalconView/trunk/public/fvw_core/GeodataDataSources/LibkmlContainerBase.cpp @ 2272

// 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.

#include "StdAfx.h"
#include "LibkmlContainerBase.h"
#include "LibkmlDataSource.h"
#include "ComErrorObject.h"
#include "kml/convenience/feature_list.h"
#include "FvOGRPolygon.h"
#include "UtilityMethods.h"

// LibkmlContainerBase

void LibkmlContainerBase::PopulateIndiciesAsNecessary()
{
   if (m_bool_indicies_populated) // may be reset within SetRegionationParameters
      return;

   bool bNeedToFireDataSourceChanged = false;

   // KML containers contain KML "features" which can be place marks or other
   // container types.  For this reason, this class implements both IFvDataSource
   // and IFvDataSet.  This method builds (three) master vectors of all of the elements
   // of the container that are data sources, that are data sets, and that are placemarks.

   size_t size = m_container->get_feature_array_size();

   for (UINT i = 0; i < size; i++)
   {
      kmldom::FeaturePtr feature = m_container->get_feature_array_at(i);

      // If the regionation parameters have been set and the feature is not active,
      // then we'll skip it.  Note that, if the regionation parameters have not been set
      // then a container is considered active
      if (m_degreesPerPixelX >= 0 && m_degreesPerPixelY >= 0 &&
         !CUtilityMethods::KMLFeatureInRegion(feature, m_leftLon, m_bottomLat, m_rightLon, m_topLat, m_degreesPerPixelX, m_degreesPerPixelY))
      {
         continue;
      }

      // if we already have a COM object for this element, use it

      UINT_TO_UNKNOWN_MAP::iterator it =  m_wrapped_objects.find(i);
      IUnknownPtr unk;

      if (it == m_wrapped_objects.end())
      {
         // this element has never been wrapped, so wrap it
         unk = CLibkmlDataSource::WrapKMLElement(feature, m_kml_file, m_rootDS);
         if (unk) // may return NULL for unsupported elements
            unk->Release(); // get rid of extra reference
         m_wrapped_objects[i] = unk;

         // we've wrapped something, so need to fire a data source changed notification
         bNeedToFireDataSourceChanged = true;
      }
      else
      {
         unk = it->second;
      }

      // save the object in the appropriate vector(s)

      IFvDataSourcePtr spDataSource = unk;
      if (spDataSource)
         m_data_sources.push_back(spDataSource);

      IFvDataSetPtr spDataSet = unk;
      if (spDataSet)
         m_data_sets.push_back(spDataSet);

      IFeaturePtr spFeature = unk;
      if (spFeature)
      {
         // save the feature and the index of the feature in the KML container
         m_features.push_back(spFeature);
         m_feature_indicies.push_back(i);
      }
   }

   m_bool_all_elements_wrapped = m_wrapped_objects.size() == size; // optimization to prevent having to rebuild unnecessarily

   m_bool_indicies_populated = TRUE; // set true here so that nested calls to this method get ignored

   if (m_bool_indicies_never_populated) // prevents firing change notice the first time this ever loads
      m_bool_indicies_never_populated = FALSE;
   else if (bNeedToFireDataSourceChanged)
      CLibkmlDataSource::FireDataSourceChanged(m_rootDS->Handle);
}

STDMETHODIMP LibkmlContainerBase::base_get_DataSetCount(LONG* count)
{
   TRY_BLOCK
   {
      PopulateIndiciesAsNecessary();
      *count = (LONG)m_data_sets.size();
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_GetDataSet(LONG index, IFvDataSet** dataSet)
{
   TRY_BLOCK
   {
      PopulateIndiciesAsNecessary();
      IFvDataSetPtr spDataSet = m_data_sets[index];
      *dataSet = spDataSet.Detach();
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_get_Name(BSTR* name)
{
   TRY_BLOCK
   {
      if (m_container->has_name())
         *name = _bstr_t(m_container->get_name().c_str()).Detach();
      else
         *name = _bstr_t(m_tag_text.c_str()).Detach();
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_get_Description(BSTR* description)
{
   TRY_BLOCK
   {
      if (m_container->has_description())
         *description = _bstr_t(m_container->get_description().c_str()).Detach();
      else
      {
         std::string s = "A ";
         s.append(m_tag_text);
         s.append(" element.");
         *description = _bstr_t(s.c_str()).Detach();
      }
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_RegisterForCallbacks(IFvDataSourceCallback* fvDataSourceCallback)
{
   TRY_BLOCK
   {
      IFvDataSourcePtr rootDS = m_rootDS;
      return rootDS->RegisterForCallbacks(fvDataSourceCallback);;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP LibkmlContainerBase::base_raw_UnregisterForCallbacks(IFvDataSourceCallback* fvDataSourceCallback)
{
   TRY_BLOCK
   {
      IFvDataSourcePtr rootDS = m_rootDS;
      return rootDS->UnregisterForCallbacks(fvDataSourceCallback);;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP LibkmlContainerBase::base_raw_GetDataSetByName(BSTR name_bstr, IFvDataSet** dataSet)
{
   return E_NOTIMPL;
}

void LibkmlContainerBase::AssociateWithLibkmlContainer(kmldom::ContainerPtr container, kmlengine::KmlFilePtr kml_file, ILibkmlDataSource* rootDS)
{
   rootDS->InternalRefAdding(); // see comments in InternalRefAdding implementation
   m_rootDS = rootDS;
   m_container = container;
   m_kml_file = kml_file;
}

void LibkmlContainerBase::CleanupFeatureVector()
{
   delete m_features_in_filter; // okay to delete NULL
   m_features_in_filter = NULL;
}

void LibkmlContainerBase::RebuildFeatureVectorAsNecessary()
{
   // This method builds m_features_in_filter, if it isn't built yet.  m_features_in_filter
   // is an array of all of the features (placemarks) that match the current filter.

   if (!m_features_in_filter)
   {
      PopulateIndiciesAsNecessary();
      m_features_in_filter = new FEATURE_VECTOR();

      // find a temporal filter within the filter
      ITemporalFilterPtr temporal_filter = m_filter;
      if (!temporal_filter)
      {
         ICompositeFilterPtr composite_filter = m_filter;
         if (composite_filter)
         {
            for (LONG i = 0; i < composite_filter->NumFilters; i++)
            {
               IFilterPtr f = composite_filter->GetFilter(i);
               temporal_filter = f;
               if (temporal_filter)
                  break;
            }
         }
      }

      // find a geometry filter within the filter
      IGeometryFilterPtr geometry_filter = m_filter;
      if (!geometry_filter)
      {
         ICompositeFilterPtr composite_filter = m_filter;
         if (composite_filter)
         {
            for (LONG i = 0; i < composite_filter->NumFilters; i++)
            {
               IFilterPtr f = composite_filter->GetFilter(i);
               geometry_filter = f;
               if (geometry_filter)
                  break;
            }
         }
      }

      // if we have a geometry filter, construct a spatial relation filter which will be used to find KML features
      // whose extents intersect the filter

      ISpatialRelationPtr spatialRelationFilter = NULL; // this will get set if we have a usuable filter
      double minXFilter, minYFilter, maxXFilter, maxYFilter; // these will be the extents of the filter rectangle

      if (geometry_filter)
      {
         // for performance, we currently only support filtering with a rectangle
         IFilterPtr filter = geometry_filter;
         CUtilityMethods::GetRectangularFilterBounds(filter, &minXFilter, &minYFilter, &maxXFilter, &maxYFilter);
         CUtilityMethods::ShiftXWindowWithinM180To360(&minXFilter, &maxXFilter);
         spatialRelationFilter = CFvOGRPolygon::constructPolygonFromEnvelope(minXFilter, maxYFilter, maxXFilter, minYFilter);
         ULONG refCountAfter = spatialRelationFilter->Release(); // verified one reference count after this release
      }

      // find the kml features that match the filter criteria and add them to m_features_in_filter

      for (FEATURE_VECTOR::size_type i = 0; i < m_features.size(); i++)
      {
         kmldom::FeaturePtr kml_feature = m_container->get_feature_array_at(m_feature_indicies[i]);

         // apply any spatial filter
         if (spatialRelationFilter)
         {
            // test whether the extents of the KML feature intersect the filter
            if (!CUtilityMethods::KMLFeatureInRectangle(kml_feature, minXFilter, minYFilter, maxXFilter, maxYFilter))
               continue;
         }

         // apply temporal filter, if there is one
         if (temporal_filter && kml_feature->has_timeprimitive())
         {
            if (!CUtilityMethods::KMLTimePrimitiveInTemporalFilter(kml_feature->get_timeprimitive(), temporal_filter))
               continue;
         }

         // if this feature is not in the region, skip it
         if (m_degreesPerPixelX >= 0 && m_degreesPerPixelY >= 0
            && !CUtilityMethods::KMLFeatureInRegion(
            kml_feature, m_leftLon, m_bottomLat, m_rightLon, m_topLat, m_degreesPerPixelX, m_degreesPerPixelY))
            continue;

         // add this feature to the list
         m_features_in_filter->push_back(m_features[i]);
      }
   }
}

STDMETHODIMP LibkmlContainerBase::base_get_FeatureCount(LONG* count)
{
   TRY_BLOCK
   {
      RebuildFeatureVectorAsNecessary();
      *count = (LONG)m_features_in_filter->size();
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_GetFeature(LONG index, IFeature** feature)
{
   TRY_BLOCK
   {
      RebuildFeatureVectorAsNecessary();
      IFeaturePtr f = m_features_in_filter->at(index);
      *feature = f.Detach();
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_GetDataSource(LONG index, IFvDataSource** dataSource)
{
   TRY_BLOCK
   {
      PopulateIndiciesAsNecessary();
      IFvDataSourcePtr spDataSource = m_data_sources[index];
      *dataSource = spDataSource.Detach();
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_get_DataSourceCount(LONG* count)
{
   TRY_BLOCK
   {
      PopulateIndiciesAsNecessary();
      *count = (LONG)m_data_sources.size();
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_GetDataSourceByName(BSTR name, IFvDataSource** dataSource)
{
   return E_NOTIMPL;
}

STDMETHODIMP LibkmlContainerBase::base_get_Filter(IFilter** filter)
{
   ULONG refCountAfterAddRef;
   if (m_filter)
      refCountAfterAddRef = m_filter->AddRef();
   *filter = m_filter;
   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_put_Filter(IFilter* filter)
{
   // !!!!!!!!!
   // NOTE:  Currently only filters geometry on envelope.  TODO: smarter, fuller featured filtering
   // !!!!!!!!!

   TRY_BLOCK
   {
      // save the filter
      m_filter = filter;

      // the feature map must be rebuilt next time it is needed
      CleanupFeatureVector();

      // apply the filter to any contained data sets

      PopulateIndiciesAsNecessary();

      LONG count;
      THROW_IF_NOT_OK(base_get_DataSetCount(&count));

      for (int index = 0; index < count; index++)
      {
         IFvDataSet* dataSet;
         THROW_IF_NOT_OK(base_raw_GetDataSet(index, &dataSet));
         HRESULT hr = dataSet->put_Filter(filter);
         ULONG refCountAfterRelease = dataSet->Release();
         if (hr != E_NOTIMPL) // E_NOTIMPL is okay since not all data sets support filtering
            THROW_IF_NOT_OK(hr);
      }
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_GetImageByIdentifier(BSTR identifier, VARIANT* imageData)
{
   TRY_BLOCK
   {
      ISymbolFactoryPtr symbol_factory = m_rootDS;
      return symbol_factory->raw_GetImageByIdentifier(identifier, imageData);
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP LibkmlContainerBase::base_raw_Extent2D(double* minX, double* minY, double* maxX, double* maxY)
{
   TRY_BLOCK
   {
      kmlengine::Bbox bbox;
      if (!kmlengine::GetFeatureBounds(m_container, &bbox))
         return E_FAIL; // feature does not have bounds
      *minX = bbox.get_west();
      *minY = bbox.get_south();
      *maxX = bbox.get_east();
      *maxY = bbox.get_north();
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_StartEditing()
{
   // set the KML factory
   m_factory = kmldom::KmlFactory::GetFactory();
   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_CopyFeature(IFeature* feature)
{
   TRY_BLOCK
   {
      if (!m_factory)
         THROW_ERROR_MSG2(E_FAIL, "must be in an editing session to copy a feature");
      kmldom::PlacemarkPtr placemark = CLibkmlDataSource::WrapFeatureInPlacemark(feature, m_factory);
      m_container->add_feature(placemark);
   }
   CATCH_BLOCK_RET

   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_raw_FinishEditing()
{
   m_factory = NULL;
   return S_OK;
}

void LibkmlContainerBase::DoTemporalDataSetAnalysisAsNecessary()
{
   // call from within a TRY_BLOCK

   if (m_bTemporalDataSetAnalysisComplete)
      return;

   m_bHasStart = FALSE;
   m_bHasEnd = FALSE;
   size_t size = m_container->get_feature_array_size();

   for (UINT i = 0; i < size; i++)
   {
      kmldom::FeaturePtr feature = m_container->get_feature_array_at(i);
      if (feature->has_timeprimitive())
      {
         kmldom::TimePrimitivePtr time_primitive = feature->get_timeprimitive();

         if (CUtilityMethods::KMLTimePrimitiveHasStart(time_primitive))
         {
            DATE start = CUtilityMethods::KMLTimePrimitiveStart(time_primitive);
            if (m_bHasStart)
            {
               if (start < m_dateStart)
                  m_dateStart = start;
            }
            else
            {
               m_dateStart = start;
               m_bHasStart = TRUE;
            }
         }

         if (CUtilityMethods::KMLTimePrimitiveHasEnd(time_primitive))
         {
            DATE end = CUtilityMethods::KMLTimePrimitiveEnd(time_primitive);
            if (m_bHasEnd)
            {
               if (end > m_dateEnd)
                  m_dateEnd = end;
            }
            else
            {
               m_dateEnd = end;
               m_bHasEnd = TRUE;
            }
         }
      }
   }

   m_bTemporalDataSetAnalysisComplete = TRUE;
}

STDMETHODIMP LibkmlContainerBase::base_get_HasStart(VARIANT_BOOL* has_start)
{
   TRY_BLOCK
   {
      DoTemporalDataSetAnalysisAsNecessary();
      *has_start = m_bHasStart;
      return S_OK;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP LibkmlContainerBase::base_get_Start(DATE* start)
{
   TRY_BLOCK
   {
      DoTemporalDataSetAnalysisAsNecessary();
      *start = m_dateStart;
      return S_OK;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP LibkmlContainerBase::base_get_HasEnd(VARIANT_BOOL* has_end)
{
   TRY_BLOCK
   {
      DoTemporalDataSetAnalysisAsNecessary();
      *has_end = m_bHasEnd;
      return S_OK;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP LibkmlContainerBase::base_get_End(DATE* end)
{
   TRY_BLOCK
   {
      DoTemporalDataSetAnalysisAsNecessary();
      *end = m_dateEnd;
      return S_OK;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP LibkmlContainerBase::base_raw_SetRegionationParameters(
   DOUBLE leftLon, DOUBLE bottomLat, DOUBLE rightLon, DOUBLE topLat,
   DOUBLE degreesPerPixelX, DOUBLE degreesPerPixelY)
{
   TRY_BLOCK
   {
      // save the regionation parameters
      m_leftLon = leftLon;
      m_bottomLat = bottomLat;
      m_rightLon = rightLon;
      m_topLat = topLat;
      m_degreesPerPixelX = degreesPerPixelX;
      m_degreesPerPixelY = degreesPerPixelY;

      // the feature map must be rebuilt next time it is needed
      CleanupFeatureVector();

      // force rebuild of indicies based on any new regionation stuff
      if (!m_bool_all_elements_wrapped)
      {
         m_bool_indicies_populated = FALSE;
         m_features.clear();
         m_feature_indicies.clear();
         m_data_sources.clear();
         m_data_sets.clear();
      }

      // apply the parameters to any contained regionated objects

      PopulateIndiciesAsNecessary();

      LONG count;
      THROW_IF_NOT_OK(base_get_DataSetCount(&count));

      for (int index = 0; index < count; index++)
      {
         IFvDataSet* dataSet;
         THROW_IF_NOT_OK(base_raw_GetDataSet(index, &dataSet));
         IRegionatedKMLContainerPtr regionatedKMLContainer = dataSet;
         if (regionatedKMLContainer)
            regionatedKMLContainer->SetRegionationParameters(leftLon, bottomLat, rightLon, topLat, degreesPerPixelX, degreesPerPixelY);
         dataSet->Release();
      }

      THROW_IF_NOT_OK(base_get_DataSourceCount(&count));

      for (int index = 0; index < count; index++)
      {
         IFvDataSource* dataSource;
         THROW_IF_NOT_OK(base_raw_GetDataSource(index, &dataSource));
         IFvDataSetPtr dataSet = dataSource;
         if (!dataSet) // skip data sets because we already did them above
         {
            IRegionatedKMLContainerPtr regionatedKMLContainer = dataSource;
            if (regionatedKMLContainer)
               regionatedKMLContainer->SetRegionationParameters(leftLon, bottomLat, rightLon, topLat, degreesPerPixelX, degreesPerPixelY);
         }
         dataSource->Release();
      }

      return S_OK;
   }
   CATCH_BLOCK_RET
}

STDMETHODIMP LibkmlContainerBase::base_raw_CheckConnectString(BSTR connectString, VARIANT_BOOL* valid)
{
   return E_NOTIMPL;
}

STDMETHODIMP LibkmlContainerBase::base_get_Visible(VARIANT_BOOL *visible)
{
   // Note that Google Earth apparently will set a container to visible if any of its children are
   // visible.  The OGC standard doesn't seem to read this way, so we only look at the container itself.
   *visible = m_container->has_visibility() ? (m_container->get_visibility() ? VARIANT_TRUE : VARIANT_FALSE) : VARIANT_TRUE;
   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_put_Visible(VARIANT_BOOL visible)
{
   m_container->set_visibility(visible ? true : false);
   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_get_Expanded(VARIANT_BOOL *expanded)
{
   *expanded = m_container->has_open() ? (m_container->get_open() ? VARIANT_TRUE : VARIANT_FALSE) : VARIANT_TRUE;
   return S_OK;
}

STDMETHODIMP LibkmlContainerBase::base_put_Expanded(VARIANT_BOOL expanded)
{
   m_container->set_open(expanded ? true : false);
   return S_OK;
}