ossimVpfAnnotationFeatureInfo.cpp

Go to the documentation of this file.

#include <sstream>

#include <ossim/imaging/ossimVpfAnnotationFeatureInfo.h>
#include <ossim/vec/ossimVpfCoverage.h>
#include <ossim/vec/ossimVpfLibrary.h>
#include <ossim/vec/ossimVpfFeatureClassSchema.h>
#include <ossim/projection/ossimProjection.h>
#include <ossim/base/ossimPolyLine.h>
#include <ossim/base/ossimGeoPolygon.h>
#include <ossim/imaging/ossimGeoAnnotationSource.h>
#include <ossim/imaging/ossimAnnotationObject.h>
#include <ossim/imaging/ossimGeoAnnotationMultiPolyLineObject.h>
#include <ossim/imaging/ossimGeoAnnotationMultiEllipseObject.h>
#include <ossim/imaging/ossimGeoAnnotationFontObject.h>
#include <ossim/imaging/ossimGeoAnnotationMultiPolyObject.h>
#include <ossim/imaging/ossimRgbImage.h>
#include <ossim/font/ossimFont.h>
#include <ossim/font/ossimFontFactoryRegistry.h>
#include <ossim/base/ossimTrace.h>

static ossimTrace traceDebug("ossimVpfAnnotationFeatureInfo:debug");

RTTI_DEF1(ossimVpfAnnotationFeatureInfo, "ossimVpfAnnotationFeatureInfo", ossimObject);

ossimVpfAnnotationFeatureInfo::ossimVpfAnnotationFeatureInfo(const ossimString& featureName,
                                                             const ossimRgbVector& penColor,
                                                             const ossimRgbVector& brushColor,
                                                             const ossimDpt& pointRadius,
                                                             int   thickness,
                                                             bool enabledFlag)
   :theName(featureName),
    thePenColor(penColor),
    theBrushColor(brushColor),
    thePointRadius(pointRadius),
    theThickness(thickness),
    theFillEnabledFlag(false),
    theEnabledFlag(enabledFlag),
    theFeatureType(ossimVpfAnnotationFeatureType_UNKNOWN),
    theFontInformation(),
    theAnnotationArray(0)
{
   ossimFont* font = ossimFontFactoryRegistry::instance()->getDefaultFont();

   if(font)
   {
      std::vector<ossimFontInformation> fontInfoArray;

      font->getFontInformation(fontInfoArray);

      if(fontInfoArray.size())
      {
         theFontInformation = fontInfoArray[0];
      }
   }
}


ossimVpfAnnotationFeatureInfo::~ossimVpfAnnotationFeatureInfo()
{
   deleteAllObjects();
}

void ossimVpfAnnotationFeatureInfo::transform(ossimImageGeometry* proj)
{
   if(theEnabledFlag)
   {
      for(int idx = 0; idx < (int)theAnnotationArray.size();++idx)
      {
         if(theAnnotationArray[idx].valid())
         {
            theAnnotationArray[idx]->transform(proj);
            theAnnotationArray[idx]->computeBoundingRect();
         }
      }
   }
}
ossimIrect ossimVpfAnnotationFeatureInfo::getBoundingProjectedRect()const
{
  ossimIrect result;
  result.makeNan();

  if(theEnabledFlag)
  {
     for(int idx = 0; idx < (int)theAnnotationArray.size();++idx)
     {
        if(theAnnotationArray[idx].valid())
    {
           ossimIrect tempRect = theAnnotationArray[idx]->getBoundingRect();
           if(!tempRect.hasNans())
           {
          if(result.hasNans())
              {
                 result = tempRect;
              }
          else
              {
                 result = result.combine(tempRect);
              }
           }
    }
     }
  }
  
  return result;
}

void ossimVpfAnnotationFeatureInfo::setEnabledFlag(bool flag)
{
   if(!flag && theEnabledFlag)
   {
      deleteAllObjects();
   }
   else if(flag&&(!theEnabledFlag))
   {
      theEnabledFlag = flag;
      buildFeature();
   }
   theEnabledFlag = flag;
}

void ossimVpfAnnotationFeatureInfo::buildFeature()
{
  deleteAllObjects();
  
  ossimVpfFeatureClassSchemaNode node;

  ossimVpfFeatureClassSchema schema;
  theCoverage.openFeatureClassSchema(schema);
  if(schema.getFeatureClassNode(theName,
                node))
    {
      if(node.thePrimitiveTable.contains("edg"))
      {
         theFeatureType = ossimVpfAnnotationFeatureType_LINE;
     if(theEnabledFlag)
       {
         buildEdgFeature(node.theTable.trim(),
                 node.theTableKey.trim(),
                 node.thePrimitiveTable.trim(),
                 node.thePrimitiveTableKey.trim());
       }
    }
      else if(node.thePrimitiveTable.contains("txt"))
    {
            theFeatureType = ossimVpfAnnotationFeatureType_TEXT;
        if(theEnabledFlag)
          {
        buildTxtFeature(node.theTable.trim(),
                node.theTableKey.trim(),
                node.thePrimitiveTable.trim(),
                node.thePrimitiveTableKey.trim());
          }
    }
      else if(node.thePrimitiveTable.contains("fac"))
    {
            theFeatureType = ossimVpfAnnotationFeatureType_POLYGON;
        if(theEnabledFlag)
          {
        buildFaceFeature(node.theTable.trim(),
                 node.theTableKey.trim(),
                 node.thePrimitiveTable.trim(),
                 node.thePrimitiveTableKey.trim());
          }
    }
      else if(node.thePrimitiveTable.contains("cnd"))
    {
            theFeatureType = ossimVpfAnnotationFeatureType_POINT;
        if(theEnabledFlag)
          {
        buildPointFeature("cnd",
                  node.theTable.trim(),
                  node.theTableKey.trim(),
                  node.thePrimitiveTable.trim(),
                  node.thePrimitiveTableKey.trim());
          }
    }
      else if(node.thePrimitiveTable.contains("end"))
    {
            theFeatureType = ossimVpfAnnotationFeatureType_POINT;
        if(theEnabledFlag)
          {
        buildPointFeature("end",
                  node.theTable.trim(),
                  node.theTableKey.trim(),
                  node.thePrimitiveTable.trim(),
                  node.thePrimitiveTableKey.trim());
          }
    }
      else
      {
         if(traceDebug())
         {
            ossimNotify(ossimNotifyLevel_DEBUG) << "Primitive \""<<node.thePrimitiveTable<<"\" not handled yet" << endl;
         }
      }
    }
}

void ossimVpfAnnotationFeatureInfo::drawAnnotations(ossimRgbImage* tile)
{
   if(theEnabledFlag)
   {
      int idx = 0;
      for(idx = 0; idx < (int)theAnnotationArray.size(); ++idx)
      {
         theAnnotationArray[idx]->draw(*tile);
      }
   }
}

bool ossimVpfAnnotationFeatureInfo::saveState(ossimKeywordlist& kwl,
                          const char* prefix)const
{
  kwl.add(prefix,
      "name",
      theName.c_str(),
      true);
  kwl.add(prefix,
      "description",
      theDescription.c_str(),
      true);
  ossimString penColor = (ossimString::toString((int)thePenColor.getR())+ " " +
              ossimString::toString((int)thePenColor.getG())+ " " +
              ossimString::toString((int)thePenColor.getB()));
  ossimString brushColor = (ossimString::toString((int)theBrushColor.getR())+ " " +
                ossimString::toString((int)theBrushColor.getG())+ " " +
                ossimString::toString((int)theBrushColor.getB()));
  kwl.add(prefix,
      "pen_color",
      penColor,
      true);
  kwl.add(prefix,
      "brush_color",
      brushColor,
      true);

  if(theFeatureType == ossimVpfAnnotationFeatureType_POINT)
    {
      kwl.add(prefix,
          "point_radius",
          ossimString::toString(thePointRadius.x) + " " +
          ossimString::toString(thePointRadius.y),
          true);
      kwl.add(prefix,
          "fill_enabled",
          theFillEnabledFlag,
          true);
    }
  else if(theFeatureType == ossimVpfAnnotationFeatureType_LINE)
    {
      kwl.add(prefix,
          "thickness",
          theThickness,
          true);
    }
  else if(theFeatureType == ossimVpfAnnotationFeatureType_POLYGON)
    {
      kwl.add(prefix,
          "fill_enabled",
          theFillEnabledFlag,
          true);
      kwl.add(prefix,
          "thickness",
          theThickness,
          true);
    }
  else if(theFeatureType == ossimVpfAnnotationFeatureType_TEXT)
    {
      theFontInformation.saveState(kwl,
                   (ossimString(prefix)+"font.").c_str());
    }
  kwl.add(prefix,
      "enabled",
      theEnabledFlag,
      true);
  kwl.add(prefix,
      "feature_type",
      getFeatureTypeAsString(),
      true);

  return true;
}

bool ossimVpfAnnotationFeatureInfo::loadState(const ossimKeywordlist& kwl,
                          const char* prefix)
{
  const char* name        = kwl.find(prefix, "name");
  const char* description = kwl.find(prefix, "description");
  const char* enabled     = kwl.find(prefix, "enabled");
  const char* fillEnabled = kwl.find(prefix, "fill_enabled");
  const char* thickness   = kwl.find(prefix, "thickness");
  const char* pointRadius = kwl.find(prefix, "point_radius");
  const char* brushColor  = kwl.find(prefix, "brush_color");
  const char* penColor    = kwl.find(prefix, "pen_color");
  
  theFontInformation.loadState(kwl,
                   (ossimString(prefix)+"font.").c_str());

  if(name)
    {
      if(theName != name)
    {
      deleteAllObjects();
    }
      theName = name;
    }
  if(description)
    {
      theDescription = description;
    }
  if(enabled)
    {
      theEnabledFlag = ossimString(enabled).toBool();

      if(!theEnabledFlag)
    {
      deleteAllObjects();
    }
    }
  
  if(fillEnabled)
    {
      theFillEnabledFlag = ossimString(fillEnabled).toBool();
    }
  if(thickness)
    {
      theThickness = ossimString(thickness).toInt();
    }
  if(pointRadius)
    {
      stringstream ptRadiusStream(pointRadius);
      ptRadiusStream >> thePointRadius.x >> thePointRadius.y;
    }
  if(brushColor)
    {
      int r, g, b;
      stringstream colorStream(brushColor);
      colorStream >> r >> g >> b;

      theBrushColor.setR((ossim_uint8)r);
      theBrushColor.setG((ossim_uint8)g);
      theBrushColor.setB((ossim_uint8)b);
    }
  if(penColor)
    {
      int r, g, b;
      stringstream colorStream(penColor);
      colorStream >> r >> g >> b;

      thePenColor.setR((ossim_uint8)r);
      thePenColor.setG((ossim_uint8)g);
      thePenColor.setB((ossim_uint8)b);
    }
  
  if(theEnabledFlag&&(theAnnotationArray.size() < 1))
    {
      buildFeature();
    }
  else
    {
      setDrawingFeaturesToAnnotation();
    }

  return true;
}

ossimString ossimVpfAnnotationFeatureInfo::getFeatureTypeAsString()const
{
   switch(theFeatureType)
   {
      case ossimVpfAnnotationFeatureType_POINT:
      {
         return "point";
      }
      case ossimVpfAnnotationFeatureType_LINE:
      {
         return "line";
      }
      case ossimVpfAnnotationFeatureType_POLYGON:
      {
         return "polygon";
      }
      case ossimVpfAnnotationFeatureType_TEXT:
      {
         return "text";
      }
      default:
         break;
   }
   
  return "unknown";
}

ossimVpfAnnotationFeatureInfo::ossimVpfAnnotationFeatureType ossimVpfAnnotationFeatureInfo::getFeatureTypeFromString(const ossimString& featureType)const
{
  ossimString downCased = featureType;
  downCased = downCased.downcase();

  if(downCased.contains("point"))
    {
      return ossimVpfAnnotationFeatureType_POINT;
    }
  else if(downCased.contains("line"))
    {
      return ossimVpfAnnotationFeatureType_LINE;
    }
  else if(downCased.contains("polygon"))
    {
      return ossimVpfAnnotationFeatureType_POLYGON;
    }
  else if(downCased.contains("text"))
    {
      return ossimVpfAnnotationFeatureType_TEXT;
    }

  return ossimVpfAnnotationFeatureType_UNKNOWN;

}

void ossimVpfAnnotationFeatureInfo::deleteAllObjects()
{
   theAnnotationArray.clear();
}

void ossimVpfAnnotationFeatureInfo::setDrawingFeaturesToAnnotation()
{
   switch(theFeatureType)
   {
   case ossimVpfAnnotationFeatureType_POINT:
   {
      ossimGeoAnnotationMultiEllipseObject* annotation = 0;
      for(int idx = 0; idx < (int)theAnnotationArray.size();++idx)
      {
         annotation = (ossimGeoAnnotationMultiEllipseObject*)theAnnotationArray[idx].get();

         annotation->setColor(thePenColor.getR(),
                              thePenColor.getG(),
                              thePenColor.getB());
         annotation->setThickness(theThickness);
         annotation->setFillFlag(theFillEnabledFlag);
         annotation->setWidthHeight(thePointRadius);
      }
      
      break;
   }
   case ossimVpfAnnotationFeatureType_TEXT:
   {
      ossimGeoAnnotationFontObject* annotation = 0;
      ossimRefPtr<ossimFont> font = ossimFontFactoryRegistry::instance()->createFont(theFontInformation);

      for(int idx = 0; idx < (int)theAnnotationArray.size();++idx)
      {
         annotation = (ossimGeoAnnotationFontObject*)theAnnotationArray[idx].get();
         annotation->setColor(thePenColor.getR(),
                              thePenColor.getG(),
                              thePenColor.getB());
         annotation->setThickness(theThickness);
         
         if(font.valid())
         {
            annotation->setFont((ossimFont*)font->dup());
         }
         annotation->setPointSize(theFontInformation.thePointSize);
         annotation->setScale(theFontInformation.theScale);
         annotation->setShear(theFontInformation.theShear);
         annotation->setRotation(theFontInformation.theRotation);
      }
      break;
   }
   case ossimVpfAnnotationFeatureType_LINE:
   {
      ossimGeoAnnotationMultiPolyLineObject* annotation = 0;
      for(int idx = 0; idx < (int)theAnnotationArray.size();++idx)
      {
         annotation = (ossimGeoAnnotationMultiPolyLineObject*)theAnnotationArray[idx].get();
         annotation->setColor(thePenColor.getR(),
                              thePenColor.getG(),
                              thePenColor.getB());
         annotation->setThickness(theThickness);
      }
      
      break;
   }
   case ossimVpfAnnotationFeatureType_POLYGON:
   {
      ossimGeoAnnotationMultiPolyObject* annotation = 0;
      for(int idx = 0; idx < (int)theAnnotationArray.size();++idx)
      {
         annotation = (ossimGeoAnnotationMultiPolyObject*)theAnnotationArray[idx].get();
         annotation->setColor(thePenColor.getR(),
                              thePenColor.getG(),
                              thePenColor.getB());
         annotation->setThickness(theThickness);
         annotation->setFillFlag(theFillEnabledFlag);
      }
      break;
   }
   default:
   {
      break;
   }
   }
}


void ossimVpfAnnotationFeatureInfo::buildTxtFeature(const ossimFilename& tableName,
                            const ossimString&   tableKey,
                            const ossimFilename& /* primitiveName */,
                            const ossimString&   /* primitiveKey */)
{
  ossimFilename tableFileName      = theCoverage.getPath().dirCat(tableName);
  ossimFilename primitiveTableName;
  ossimVpfTable table;
  ossimVpfTable primitiveTable;

  if(table.openTable(tableFileName))
    {
      table.reset();
      vector<ossimString> columnValues = table.getColumnValues(tableKey.trim());
      
      primitiveTableName = theCoverage.getPath().dirCat("txt");
      
      vector<ossimString> tileIds;
      ossim_int32 stringValuePosition = 0;
      ossim_int32 shapeLinePosition = 0;
      bool isTiled = false;
      if(table.getColumnPosition("tile_id") >= 0)
    {
      tileIds = table.getColumnValues("tile_id");
      isTiled = true;
    }
      if(!isTiled)
    {
      primitiveTableName = theCoverage.getPath().dirCat("txt");
      if(!primitiveTable.openTable(primitiveTableName))
        {
          return;
        }
      stringValuePosition = primitiveTable.getColumnPosition("string");
      shapeLinePosition   = primitiveTable.getColumnPosition("shape_line");
    }
      ossim_int32 tileId = -1;
      for(ossim_uint32 idx = 0; idx < columnValues.size();++idx)
    {
      if(isTiled)
        {
          if(tileId != tileIds[idx].toInt())
        {
          tileId = tileIds[idx].toInt();
          ossimFilename filename = theCoverage.getLibrary()->getTileName(tileIds[idx].toInt());
          if(theCoverage.getPath().dirCat(filename).dirCat("txt").exists())
            {
              primitiveTableName = theCoverage.getPath().dirCat(filename).dirCat("txt");
            }
          else if(theCoverage.getPath().dirCat(filename.downcase()).dirCat("txt").exists())
            {
              primitiveTableName = theCoverage.getPath().dirCat(filename.downcase()).dirCat("txt");
            }
          if(!primitiveTable.openTable(primitiveTableName))
            {
              return;
            }
          stringValuePosition = primitiveTable.getColumnPosition("string");
          shapeLinePosition   = primitiveTable.getColumnPosition("shape_line");
        }
        }
      row_type row = read_row( columnValues[idx].toInt(), 
                   *primitiveTable.getVpfTableData());
      ossim_int32 count = 0;
      ossimDpt* ptArray = getXy(*primitiveTable.getVpfTableData(),
                    row,
                    shapeLinePosition,
                    &count);
      ossimDpt midPoint;
      if(ptArray)
        {
          midPoint = *ptArray;
          
          delete [] ptArray;
        }
      ossimString stringValue = primitiveTable.getColumnValueAsString(row,
                                      stringValuePosition);
      free_row(row,  *primitiveTable.getVpfTableData());
      
      if(!midPoint.hasNans())
        {
          ossimGpt centerPoint(midPoint.lat,
                   midPoint.lon,
                   ossim::nan());
              ossimFont* font = ossimFontFactoryRegistry::instance()->createFont(theFontInformation);
          ossimGeoAnnotationFontObject* annotation = new ossimGeoAnnotationFontObject(centerPoint,
                                              stringValue);
              annotation->setColor(thePenColor.getR(),
                                   thePenColor.getG(),
                                   thePenColor.getB());
              annotation->setThickness(theThickness);
                 
              annotation->setFont(font);
          annotation->setPointSize(theFontInformation.thePointSize);
          annotation->setScale(theFontInformation.theScale);
          annotation->setShear(theFontInformation.theShear);
          annotation->setRotation(theFontInformation.theRotation);
          theAnnotationArray.push_back(annotation);
        }
    }  
    }
}

void ossimVpfAnnotationFeatureInfo::buildEdgFeature(const ossimFilename& tableName,
                            const ossimString&   tableKey,
                            const ossimFilename& /* primitiveName */,
                            const ossimString&   /* primitiveKey */)
{
   ossimFilename tableFileName      = theCoverage.getPath().dirCat(tableName);
   ossimFilename primitiveTableName;
   ossimVpfTable table;
   ossimVpfTable primitiveTable;
  
   std::vector<ossimPolyLine> polyLineArray;

   if(table.openTable(tableFileName))
   {
      
      vector<ossimString> columnValues = table.getColumnValues(tableKey.trim());
      vector<ossimString> tileIds;
      bool isTiled = false;
      if(table.getColumnPosition("tile_id") >= 0)
      {
         tileIds = table.getColumnValues("tile_id");
         isTiled = true;
      }
      ossim_int32 coordinateValuePosition = 0;
      if(!isTiled)
      {
         primitiveTableName = theCoverage.getPath().dirCat("edg");
         if(!primitiveTable.openTable(primitiveTableName))
         {
            return;
         }
         coordinateValuePosition = primitiveTable.getColumnPosition("coordinates");
      }
      ossim_int32 tileId = -1;
      for(ossim_uint32 idx = 0; idx < columnValues.size();++idx)
      {
         if(isTiled)
         {
            if(tileId != tileIds[idx].toInt())
            {
               tileId = tileIds[idx].toInt();
               ossimFilename filename = theCoverage.getLibrary()->getTileName(tileIds[idx].toInt());
               if(theCoverage.getPath().dirCat(filename).dirCat("edg").exists())
               {
                  primitiveTableName = theCoverage.getPath().dirCat(filename).dirCat("edg");
               }
               else if(theCoverage.getPath().dirCat(filename.downcase()).dirCat("edg").exists())
               {
                  primitiveTableName = theCoverage.getPath().dirCat(filename.downcase()).dirCat("edg");
               }
               if(!primitiveTable.openTable(primitiveTableName))
               {
                  return;
               }
               coordinateValuePosition = primitiveTable.getColumnPosition("coordinates");
            }
         }
         ossimPolyLine polyLine;
      
         readEdge(polyLine,
                  columnValues[idx].toInt(),
                  coordinateValuePosition,
                  primitiveTable);

     readAttributes(polyLine, table, idx + 1); // third parm is one-based row
      
         polyLineArray.push_back(polyLine);
      }
   }
   ossimGeoAnnotationMultiPolyLineObject* annotation = new ossimGeoAnnotationMultiPolyLineObject(polyLineArray);
   annotation->setColor(thePenColor.getR(),
                        thePenColor.getG(),
                        thePenColor.getB());
   annotation->setThickness(theThickness);
   theAnnotationArray.push_back(annotation);
}

void ossimVpfAnnotationFeatureInfo::readAttributes(ossimPolyLine& polyLine, ossimVpfTable& table, int row) {
  int numCols = table.getNumberOfColumns();

  for (int col = 0; col < numCols; col ++) {
    polyLine.addAttribute( table.getColumnValueAsString( row, col ));
  }
}

void ossimVpfAnnotationFeatureInfo::buildPointFeature(const ossimString& primitiveName,
                              const ossimFilename& tableName,
                              const ossimString&   tableKey,
                              const ossimFilename& /* primitive */,
                              const ossimString&   /* primitiveKey */)
{
  ossimFilename tableFileName      = theCoverage.getPath().dirCat(tableName);
  ossimFilename primitiveTableName;
  ossimVpfTable table;
  ossimVpfTable primitiveTable;
  
  std::vector<ossimGpt> centerPointArray;

  if(table.openTable(tableFileName))
    {
      
      vector<ossimString> columnValues = table.getColumnValues(tableKey.trim());
      vector<ossimString> tileIds;
      bool isTiled = false;
      if(table.getColumnPosition("tile_id") >= 0)
    {
      tileIds = table.getColumnValues("tile_id");
      isTiled = true;
    }
      ossim_int32 coordinateValuePosition = 0;
      if(!isTiled)
    {
      primitiveTableName = theCoverage.getPath().dirCat(primitiveName);
      if(!primitiveTable.openTable(primitiveTableName))
        {
          return;
        }
      coordinateValuePosition = primitiveTable.getColumnPosition("coordinate");
    }
      ossim_int32 tileId = -1;
      for(ossim_uint32 idx = 0; idx < columnValues.size();++idx)
    {
      if(isTiled)
        {
          if(tileId != tileIds[idx].toInt())
        {
          tileId = tileIds[idx].toInt();
          ossimFilename filename = theCoverage.getLibrary()->getTileName(tileIds[idx].toInt());
          if(theCoverage.getPath().dirCat(filename).dirCat(primitiveName).exists())
            {
              primitiveTableName = theCoverage.getPath().dirCat(filename).dirCat(primitiveName);
            }
          else if(theCoverage.getPath().dirCat(filename.downcase()).dirCat(primitiveName).exists())
            {
              primitiveTableName = theCoverage.getPath().dirCat(filename.downcase()).dirCat(primitiveName);
            }
          if(!primitiveTable.openTable(primitiveTableName))
            {
              return;
            }
          coordinateValuePosition = primitiveTable.getColumnPosition("coordinate");
        }
        }
      row_type row = read_row( columnValues[idx].toInt(), 
                   *primitiveTable.getVpfTableData());

      ossim_int32 count = 0;
      ossimDpt* ptArray = getXy(*primitiveTable.getVpfTableData(),
                    row,
                    coordinateValuePosition,
                    &count);
      
      if(ptArray)
        {
          for(int i = 0; i < count; ++i)
        {
          if((fabs(ptArray[i].x) <= 180.0)&&
             (fabs(ptArray[i].y) <= 90.0))
            {
              centerPointArray.push_back(ossimGpt(ptArray[i].lat,
                              ptArray[i].lon,
                              ossim::nan()));
            }
        }
          delete [] ptArray;
        }
      free_row(row,  *primitiveTable.getVpfTableData());
    }
    }
  ossimGeoAnnotationMultiEllipseObject* annotation = new ossimGeoAnnotationMultiEllipseObject(centerPointArray,
                                                  ossimDpt(2,2));
  annotation->setColor(thePenColor.getR(),
                       thePenColor.getG(),
                       thePenColor.getB());
  annotation->setThickness(theThickness);
  annotation->setFillFlag(theFillEnabledFlag);
  annotation->setWidthHeight(thePointRadius);
  theAnnotationArray.push_back(annotation);
}

int myFaceCount = 0;

void ossimVpfAnnotationFeatureInfo::buildFaceFeature(const ossimFilename& tableName,
                             const ossimString&   tableKey, // face_id
                             const ossimFilename& /* primitive */, //face
                             const ossimString&   /* primitiveKey */) // id
{
   ossimFilename tableFileName      = theCoverage.getPath().dirCat(tableName);
   ossimFilename primitiveTableName;
   ossimFilename rngTableName;
   ossimFilename edgTableName;
   ossimVpfTable table;
   ossimVpfTable primitiveTable;
   ossimVpfTable rngTable;
   ossimVpfTable edgTable;
   vector<ossimGeoPolygon> thePolyList;
  
   if(table.openTable(tableFileName))
   {
      vector<ossimString> columnValues = table.getColumnValues(tableKey.trim()); // fac_id
      vector<ossimString> tileIds;
      bool isTiled = false;
      if(table.getColumnPosition("tile_id") >= 0)
      {
         tileIds = table.getColumnValues("tile_id");
         isTiled = true;
      }
      // ossim_int32 coordinateValuePosition = 0;
      ossim_int32 startEdgePosition = 0;
      ossim_int32 rngPtrPosition = 0;
      if(!isTiled)
      {
         primitiveTableName = theCoverage.getPath().dirCat("fac");
         rngTableName = theCoverage.getPath().dirCat("rng");
         edgTableName = theCoverage.getPath().dirCat("edg");
         if(!primitiveTable.openTable(primitiveTableName)||
            !rngTable.openTable(rngTableName)||
            !edgTable.openTable(edgTableName))
         {
            return;
         }
         // coordinateValuePosition = edgTable.getColumnPosition("coordinates");
         startEdgePosition = rngTable.getColumnPosition("start_edge");
         rngPtrPosition = primitiveTable.getColumnPosition("ring_ptr");
      } // else will get for each face in loop below

      ossim_int32 tileId = -1;

      for(ossim_uint32 idx = 0; idx < columnValues.size();++idx) // for each face feature
      {
         if(isTiled)        // then get table names because we didn't get them above
         {
            if((tileId != tileIds[idx].toInt())||
               (tileId < 0))
            {
               tileId = tileIds[idx].toInt();
               ossimFilename filename = theCoverage.getLibrary()->getTileName(tileIds[idx].toInt());
               if(theCoverage.getPath().dirCat(filename).dirCat("fac").exists())
               {
                  primitiveTableName = theCoverage.getPath().dirCat(filename).dirCat("fac");
                  rngTableName = theCoverage.getPath().dirCat(filename).dirCat("rng");
                  edgTableName = theCoverage.getPath().dirCat(filename).dirCat("edg");
               }
               else if(theCoverage.getPath().dirCat(filename.downcase()).dirCat("fac").exists())
               {
                  primitiveTableName = theCoverage.getPath().dirCat(filename.downcase()).dirCat("fac");
                  rngTableName = theCoverage.getPath().dirCat(filename.downcase()).dirCat("rng");
                  edgTableName = theCoverage.getPath().dirCat(filename.downcase()).dirCat("edg");
               }
               if(!primitiveTable.openTable(primitiveTableName)||
                  !rngTable.openTable(rngTableName)||
                  !edgTable.openTable(edgTableName))
               {
                  return;
               }
               // coordinateValuePosition = edgTable.getColumnPosition("coordinates");
               startEdgePosition = rngTable.getColumnPosition("start_edge");
               rngPtrPosition = primitiveTable.getColumnPosition("ring_ptr");
            }
         } // if(isTiled)

         // get the outer ring id for this face
         int thisFaceId = columnValues[idx].toInt();
         int rngId = -1;

         if (thisFaceId <= primitiveTable.getNumberOfRows())
        rngId = readRngId(thisFaceId,
                  rngPtrPosition,
                  primitiveTable);           // face table
         else
            if(traceDebug())
            {
               ossimNotify(ossimNotifyLevel_DEBUG) << "not getting face " << thisFaceId << " from tile " << tileId << " " << primitiveTableName <<
                  " bacause it has only " << primitiveTable.getNumberOfRows() << " rows" << endl;
            }

         if(rngId > 0)
         {
            int startEdge = readStartEdgeId(rngId,
                                            startEdgePosition,
                                            rngTable);
            int outerStartEdge = startEdge;
            if(startEdge > 0 )
            {
               ossimGeoPolygon polygon;
                 
               myFaceCount ++;
                 
               int ringTableFaceIdColumn = rngTable.getColumnPosition("face_id");
               int ringFaceId = readTableCellAsInt(rngId, ringTableFaceIdColumn, rngTable);
                 
               if (thisFaceId != ringFaceId) {
                  // as of Mon Dec 20 2004, this has not been observed in vmap0 or vmap1
                  if(traceDebug())
                  {
                     ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting face " << thisFaceId << " from " << tableFileName <<
                        " because it's ring (" << rngId << ") has face " << ringFaceId << " and startEdgeId " << startEdge << endl;
                  }
               } else {
                  readGeoPolygon( polygon,
                                  thisFaceId,
                                  startEdge,
                                  edgTable );
                    
                  // get the inner rings (holes)
                  int faceIdPosition = rngTable.getColumnPosition("face_id");
                  int innerRingOffset = 1;
                  int rowFaceId = -1;
                  if (rngId + innerRingOffset <= rngTable.getNumberOfRows())
                     rowFaceId = rngTable.getColumnValueAsString( rngId + innerRingOffset, faceIdPosition ).toInt();
                  while (rowFaceId == thisFaceId && rngId + innerRingOffset <= rngTable.getNumberOfRows()) {    // while there are more inner rings
                     startEdge = readStartEdgeId(rngId + innerRingOffset, startEdgePosition, rngTable);

                     if (startEdge == outerStartEdge) {
            // as of Mon Dec 20 2004, this has not been observed in vmap0 or vmap1
                        if(traceDebug())
                        {
                           ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting hole in face "
                                                               << thisFaceId << " because inner ring "
                                                               << rngId + innerRingOffset
                                                               << " touches outer ring " << rngId << endl;
                        }

            innerRingOffset ++;
            rowFaceId = rngTable.getColumnValueAsString( rngId + innerRingOffset, faceIdPosition ).toInt();
            continue;
                     }

                     if(startEdge > 0 )
                     {
                        ossimGeoPolygon holePolygon;
          
                        readGeoPolygon( holePolygon,
                                        thisFaceId,
                                        startEdge,
                                        edgTable );
                        if(holePolygon.size())
                           polygon.addHole( holePolygon );
                     }

                     innerRingOffset ++;
                     if (rngId + innerRingOffset <= rngTable.getNumberOfRows())
                        rowFaceId = rngTable.getColumnValueAsString( rngId + innerRingOffset, faceIdPosition ).toInt();
                  }

                  readAttributes(polygon, table, idx + 1); // third parm is one-based row

                  thePolyList.push_back(polygon);
               }
            }
         }
      } // each fac_id
   }
   ossimGeoAnnotationMultiPolyObject* annotation = new ossimGeoAnnotationMultiPolyObject(thePolyList);
   annotation->setColor(thePenColor.getR(),
                        thePenColor.getG(),
                        thePenColor.getB());
   annotation->setThickness(theThickness);
   annotation->setFillFlag(theFillEnabledFlag);
  
   theAnnotationArray.push_back(annotation);
}

void ossimVpfAnnotationFeatureInfo::readAttributes(ossimGeoPolygon& polygon, ossimVpfTable& table, int row) {
  int numCols = table.getNumberOfColumns();

  for (int col = 0; col < numCols; col ++) {
    ossimString s = table.getColumnValueAsString( row, col );
    polygon.addAttribute( s );
  }
}

/* GET_XY                                                                    */
/*****************************************************************************/
ossimDpt *ossimVpfAnnotationFeatureInfo::getXy(vpf_table_type table, 
                           row_type row, 
                           ossim_int32 pos, 
                           ossim_int32 *count)
{
   ossim_int32 i;
   ossimDpt *coord = 0;
  
   switch (table.header[pos].type)
   {
      case 'C':
      {
         coordinate_type temp, *ptr;
         ptr = (coordinate_type*)get_table_element(pos, row, table, &temp, count);
         coord = new ossimDpt[*count];
         if ((*count == 1) && (ptr == (coordinate_type*)0))
         {
            coord->x = (double)temp.x;
            coord->y = (double)temp.y;
         }
         else 
         {
        for (i=0; i<*count; i++)
            {
               coord[i].x = (double)ptr[i].x;
               coord[i].y = (double)ptr[i].y;
            }
         }
         if (ptr)
         {
            free((char *)ptr);
         }
         break;
      }
      case 'Z':
      {
         tri_coordinate_type temp, *ptr;
         ptr = (tri_coordinate_type*)get_table_element (pos, row, table, &temp, count);
     coord = new ossimDpt[*count];
         if ((*count == 1) && (ptr == (tri_coordinate_type*)0))
         {
            coord->x = (double)temp.x;
            coord->y = (double)temp.y;
         }
         else
         {
            for (i=0; i<*count; i++)
            {
               coord[i].x = (double)ptr[i].x;
               coord[i].y = (double)ptr[i].y;
            }
         }
         if (ptr)
         {
            free ((char*)ptr);
         }
         break;
      }
      case 'B':
      {
         double_coordinate_type temp, *ptr;
         ptr = (double_coordinate_type*)get_table_element (pos, row, table, &temp, count);
         coord = new ossimDpt[*count];
         if ((*count == 1) && (ptr == (double_coordinate_type*)0))
         {
            coord->x = temp.x;
            coord->y = temp.y;
         }
         else
         {
        for (i=0; i<*count; i++)
            {
               coord[i].x = ptr[i].x;
               coord[i].y = ptr[i].y;
            }
         }
         if (ptr)
         {
        free ((char*)ptr);
         }
         break;
      }
      case 'Y':
      {
         double_tri_coordinate_type temp, *ptr;
         ptr = (double_tri_coordinate_type*)get_table_element (pos, row, table, &temp, count);
         coord = new ossimDpt[*count];
         if ((*count == 1) && (ptr == (double_tri_coordinate_type*)0))
         {
            coord->x = temp.x;
            coord->y = temp.y;
         }
         else
         {
            for (i=0; i<*count; i++)
            {
               coord[i].x = ptr[i].x;
               coord[i].y = ptr[i].y;
            }
         }
         if (ptr)
         {
        free((char*)ptr);
         }
         break;
      }
      
      default:
         break;
   } /* switch type */
   return (coord);
}

int ossimVpfAnnotationFeatureInfo::readTableCellAsInt (int rowNumber,
                               int colNumber,
                               ossimVpfTable& table)
{
  int result = -1;
  row_type row = read_row( rowNumber, *table.getVpfTableData());
  
  result = table.getColumnValueAsString(row, colNumber).toInt();
  
  free_row(row, *table.getVpfTableData());
  
  return result;
}

int ossimVpfAnnotationFeatureInfo::readRngId(int rowNumber,
                         int colNumber,
                         ossimVpfTable& faceTable)
{
  int idResult = -1;
  row_type row = read_row( rowNumber, 
               *faceTable.getVpfTableData());
  
  idResult = faceTable.getColumnValueAsString(row,
                          colNumber).toInt();
  
  free_row(row, *faceTable.getVpfTableData());
  
  return idResult;
}

int ossimVpfAnnotationFeatureInfo::readStartEdgeId(int rowNumber,
                           int colNumber,
                           ossimVpfTable& rngTable)
{
  int idResult = -1;

  row_type row = read_row( rowNumber, 
               *rngTable.getVpfTableData());
  
  idResult = rngTable.getColumnValueAsString(row,
                         colNumber).toInt();
  
  free_row(row, *rngTable.getVpfTableData());
  
  return idResult;
  
}

int ossimVpfAnnotationFeatureInfo::getEdgeKeyId (vpf_table_type& table, row_type& row, int col) {
    id_triplet_type key;
    ossim_int32 keyCount;
    get_table_element( col,
               row,
               table,
               & key,
               & keyCount );
    return key.id;
}

void ossimVpfAnnotationFeatureInfo::readGeoPolygon(ossimGeoPolygon& polygon,
                           int faceId,
                           int startEdgeId,
                           ossimVpfTable& edgTable) {

  ossim_int32 coordinatesCol = edgTable.getColumnPosition( "coordinates" );
  ossim_int32 startNodeCol = edgTable.getColumnPosition( "start_node" );
  ossim_int32 endNodeCol = edgTable.getColumnPosition( "end_node" );
  ossim_int32 rightEdgeCol = edgTable.getColumnPosition( "right_edge" );
  ossim_int32 leftEdgeCol = edgTable.getColumnPosition( "left_edge" );
  ossim_int32 rightFaceCol = edgTable.getColumnPosition( "right_face" );
  ossim_int32 leftFaceCol = edgTable.getColumnPosition( "left_face" );

  // collect edges
  vector < int > edges;
  int lastEdge = startEdgeId;
  edges.push_back( lastEdge );

  row_type row = read_row( startEdgeId, *edgTable.getVpfTableData() );
  int startNode = edgTable.getColumnValueAsString( row, startNodeCol ).toInt();
  int endNode = edgTable.getColumnValueAsString( row, endNodeCol ).toInt();

  if (startNode != endNode) { // there's more than one edge to this ring
    int rightFace = getEdgeKeyId( *edgTable.getVpfTableData(), row, rightFaceCol );
    int leftFace = getEdgeKeyId( *edgTable.getVpfTableData(), row, leftFaceCol );
    int rightEdge = getEdgeKeyId( *edgTable.getVpfTableData(), row, rightEdgeCol );
    int leftEdge = getEdgeKeyId( *edgTable.getVpfTableData(), row, leftEdgeCol );
    int nextEdge;
    int firstNode, lastNode;

    if (rightFace == leftFace) {
      if (rightEdge == leftEdge) {
    free_row(row,  *edgTable.getVpfTableData());
    // as of Mon Dec 20 2004, this has not been observed in vmap0 or vmap1
    // cout << "rejecting floating line face " << faceId << " line " << __LINE__ << endl;
    return;
      }

      // this is a dangling start edge; find a non dangling edge to use as the start edge
      int dirRight = 1;
      int nextEdge = startEdgeId;
      int nextLeftFace = leftFace;
      int nextRightFace = rightFace;
      int mobiusLimit = 1000;

      while (nextLeftFace == nextRightFace) {
    if (-- mobiusLimit < 0) {
        free_row(row,  *edgTable.getVpfTableData());
            if(traceDebug())
            {
               ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting mobius face " << faceId << " line " << __LINE__ << endl;
            }
        return;
    }

    int thisEdge = nextEdge;
    if (dirRight) {
      nextEdge = getEdgeKeyId( *edgTable.getVpfTableData(), row, rightEdgeCol );
      if (nextEdge == thisEdge)
        dirRight = 0;
      else if (nextEdge == startEdgeId) {
        free_row(row,  *edgTable.getVpfTableData());
            if(traceDebug())
            {
               ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting mobius face " << faceId << " line " << __LINE__ << endl;
            }
        return;
      }
    } else {
      nextEdge = getEdgeKeyId( *edgTable.getVpfTableData(), row, leftEdgeCol );
      if (nextEdge == thisEdge) {
        free_row(row,  *edgTable.getVpfTableData());
        // as of Mon Dec 20 2004, this has not been observed in vmap0 or vmap1
        // cout << "rejecting multi floating line face " << faceId << " line " << __LINE__ << endl;
        return;
      } else if (nextEdge == startEdgeId) {
        free_row(row,  *edgTable.getVpfTableData());
            if(traceDebug())
            {
               ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting mobius face " << faceId << " line " << __LINE__ << endl;
            }
        return;
      }
    }
    free_row(row,  *edgTable.getVpfTableData());
    row = read_row( nextEdge, *edgTable.getVpfTableData() );
    nextRightFace = getEdgeKeyId( *edgTable.getVpfTableData(), row, rightFaceCol );
    nextLeftFace = getEdgeKeyId( *edgTable.getVpfTableData(), row, leftFaceCol );
      }

      startEdgeId = nextEdge;
      rightFace = nextRightFace;
      leftFace = nextLeftFace;
      free_row(row,  *edgTable.getVpfTableData());
      row = read_row( startEdgeId, *edgTable.getVpfTableData() );
      startNode = edgTable.getColumnValueAsString( row, startNodeCol ).toInt();
      endNode = edgTable.getColumnValueAsString( row, endNodeCol ).toInt();
    }

    if (rightFace == faceId) {
      nextEdge = getEdgeKeyId( *edgTable.getVpfTableData(), row, rightEdgeCol );
      firstNode = startNode;
      lastNode = endNode;
    } else if (leftFace == faceId) {
      nextEdge = getEdgeKeyId( *edgTable.getVpfTableData(), row, leftEdgeCol );
      firstNode = endNode;
      lastNode = startNode;
    }
    else
    {
       if(traceDebug())
       {
          ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting face " << faceId << " line " << __LINE__ << endl;
       }
       return;
    }

    row_type nextRow;
    while (true) {
      nextRow = read_row( nextEdge, *edgTable.getVpfTableData() );
      int nextLeftEdge = getEdgeKeyId( *edgTable.getVpfTableData(), nextRow, leftEdgeCol );
      int nextRightEdge = getEdgeKeyId( *edgTable.getVpfTableData(), nextRow, rightEdgeCol );
      int nextLeftFace = getEdgeKeyId( *edgTable.getVpfTableData(), nextRow, leftFaceCol );
      int nextRightFace = getEdgeKeyId( *edgTable.getVpfTableData(), nextRow, rightFaceCol );
      int nextStartNode = edgTable.getColumnValueAsString( nextRow, startNodeCol ).toInt();
      int nextEndNode = edgTable.getColumnValueAsString( nextRow, endNodeCol ).toInt();

      while (nextLeftFace == nextRightFace) {
    int lastEnd;
    if (rightFace == faceId)
      lastEnd = edgTable.getColumnValueAsString( row, endNodeCol ).toInt();
    else
      lastEnd = edgTable.getColumnValueAsString( row, startNodeCol ).toInt();

    if (lastEnd == nextStartNode)
      nextEdge = nextLeftEdge;
    else if (lastEnd == nextEndNode)
      nextEdge = nextRightEdge;
    else {          // bad face
           if(traceDebug())
           {
              ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting face " << faceId << " line " << __LINE__ << endl;
           }
      return;
    }
    if (lastEdge == nextEdge)
        { // bad face
           if(traceDebug())
           {
              ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting face " << faceId << " line " << __LINE__ << endl;
           }
           return;
    }

    free_row(nextRow,  *edgTable.getVpfTableData());
    nextRow = read_row( nextEdge, *edgTable.getVpfTableData() );
    nextLeftEdge = getEdgeKeyId( *edgTable.getVpfTableData(), nextRow, leftEdgeCol );
    nextRightEdge = getEdgeKeyId( *edgTable.getVpfTableData(), nextRow, rightEdgeCol );
    nextLeftFace = getEdgeKeyId( *edgTable.getVpfTableData(), nextRow, leftFaceCol );
    nextRightFace = getEdgeKeyId( *edgTable.getVpfTableData(), nextRow, rightFaceCol );
    nextStartNode = edgTable.getColumnValueAsString( nextRow, startNodeCol ).toInt();
    nextEndNode = edgTable.getColumnValueAsString( nextRow, endNodeCol ).toInt();
      }
    
      lastEdge = nextEdge;
      edges.push_back( lastEdge );

      {
    int lastEnd;
    if (nextRightFace == faceId) {
      if (lastNode != nextStartNode) {
             if(traceDebug())
             {
                ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting face " << faceId << " line " << __LINE__ << endl;
             }
        return;
      }
      lastEnd = nextEndNode;
    } else if (nextLeftFace == faceId) {
      if (lastNode != nextEndNode) {
             if(traceDebug())
             {
                ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting face " << faceId << " line " << __LINE__ << endl;
             }
        return;
      }
      lastEnd = nextStartNode;
    } else {
           if(traceDebug())
           {
              ossimNotify(ossimNotifyLevel_DEBUG) << "rejecting face " << faceId << " line " << __LINE__ << endl;
           }
      return;
    }

    if (lastEnd == firstNode)
      break;
      }

      free_row(row,  *edgTable.getVpfTableData());
      row = nextRow;
      startNode = nextStartNode;
      endNode = nextEndNode;
      rightFace = nextRightFace;
      leftFace = nextLeftFace;

      if (rightFace == faceId) {
    nextEdge = nextRightEdge;
    lastNode = endNode;
      } else {
    nextEdge = nextLeftEdge;
    lastNode = startNode;
      }
    }

    free_row(nextRow,  *edgTable.getVpfTableData());
    nextRow = 0;
  }

  for (vector< int >::iterator i = edges.begin(); i != edges.end(); i++) {
    ossim_int32 count = 0;
    free_row(row,  *edgTable.getVpfTableData());
    row = read_row( *i, *edgTable.getVpfTableData() );
    ossimDpt* ptArray = getXy(*edgTable.getVpfTableData(),
                  row,
                  coordinatesCol,
                  &count);
  
    if(ptArray)
    {
       int rightFace = getEdgeKeyId( *edgTable.getVpfTableData(), row, rightFaceCol );
       
       if (rightFace == faceId)
       {
      for(int p = 0; p < count; ++p)
          {
             if((fabs(ptArray[p].x) <= 180.0)&&
                (fabs(ptArray[p].y) <= 90.0))
             {
                polygon.addPoint(ptArray[p].y, ptArray[p].x);
             }
          }
       }
       else
       {
      for(int p = count - 1; p >= 0; --p)
          {
             if((fabs(ptArray[p].x) <= 180.0)&&
                (fabs(ptArray[p].y) <= 90.0))
             {
                polygon.addPoint(ptArray[p].y, ptArray[p].x);
             }
          }
       }
       delete [] ptArray;
    }
  }
  free_row(row,  *edgTable.getVpfTableData());
}

void ossimVpfAnnotationFeatureInfo::readEdge(ossimPolyLine& polyLine,
                         int rowNumber,
                         int colPosition,
                         ossimVpfTable& edgeTable)
{
  polyLine.clear();
  row_type row = read_row( rowNumber, 
               *edgeTable.getVpfTableData());

  ossim_int32 count = 0;
  ossimDpt* ptArray = getXy(*edgeTable.getVpfTableData(),
                row,
                colPosition,
                &count);
  
  if(ptArray)
    {
      for(int i = 0; i < count; ++i)
    {
      if((fabs(ptArray[i].x) <= 180.0)&&
         (fabs(ptArray[i].y) <= 90.0))
        {
          polyLine.addPoint(ossimDpt(ptArray[i].x,
                     ptArray[i].y));
        }
    }
      delete [] ptArray;
    }
  free_row(row,  *edgeTable.getVpfTableData());
}