void ossimQuadTreeWarp::create(const ossimDrect& boundingRect,
                               const ossimDpt& ulShift,
                               const ossimDpt& urShift,
                               const ossimDpt& lrShift,
                               const ossimDpt& llShift)
{
   clear();

   theTree = new ossimQuadTreeWarpNode(boundingRect);

   ossimQuadTreeWarpVertex* ul = new ossimQuadTreeWarpVertex(boundingRect.ul(),
                                                             ulShift);
   ossimQuadTreeWarpVertex* ur = new ossimQuadTreeWarpVertex(boundingRect.ur(),
                                                             urShift);
   ossimQuadTreeWarpVertex* lr = new ossimQuadTreeWarpVertex(boundingRect.lr(),
                                                             lrShift);
   ossimQuadTreeWarpVertex* ll = new ossimQuadTreeWarpVertex(boundingRect.ll(),
                                                             llShift);
   ul->addSharedNode(theTree);
   ur->addSharedNode(theTree);
   lr->addSharedNode(theTree);
   ll->addSharedNode(theTree);

   theVertexList.push_back(ul);
   theVertexList.push_back(ur);
   theVertexList.push_back(lr);
   theVertexList.push_back(ll);
   
   theTree->theUlVertex = ul;
   theTree->theUrVertex = ur;
   theTree->theLrVertex = lr;
   theTree->theLlVertex = ll;
   
}
Beispiel #2
0
ossimPolygon::ossimPolygon(const ossimDrect& rect)
   : theVertexList(4),
     theCurrentVertex(0),
     theOrderingType(OSSIM_CLOCKWISE_ORDER)
{
   theVertexList[0] = rect.ul();
   theVertexList[1] = rect.ur();
   theVertexList[2] = rect.lr();
   theVertexList[3] = rect.ll();
}
void oms::SingleImageChain::setImageCut(const ossimDrect& rect)
{
   std::vector<ossimDpt> pointList(4);
   pointList[0] = rect.ul();
   pointList[1] = rect.ur();
   pointList[2] = rect.lr();
   pointList[3] = rect.ll();
   
   setImageCut(pointList);
}
Beispiel #4
0
bool ossimPolygon::clipToRect(vector<ossimPolygon>& result,
                              const ossimDrect& rect)const
{
   result.clear();
   ossimPolyArea2d p1(*this);
   ossimPolyArea2d p2(rect.ul(), rect.ur(), rect.lr(), rect.ll());
   
   p1&=p2;

   p1.getVisiblePolygons(result);

   return (result.size() > 0);
}   
void oms::SingleImageChain::setViewCut(const ossimDrect& rect, bool imageSpaceFlag)
{
   if(!imageSpaceFlag)
   {
      
      const ossimProjection* proj = getViewProjection();
      
      if(proj)
      {
         std::vector<ossimGpt> pointList(4);
         proj->lineSampleToWorld(rect.ul(), pointList[0]);
         proj->lineSampleToWorld(rect.ur(), pointList[1]);
         proj->lineSampleToWorld(rect.lr(), pointList[2]);
         proj->lineSampleToWorld(rect.ll(), pointList[3]);
         setViewCut(pointList);
      }
   }
   else
   {
      std::vector<ossimDpt> pointList(4);
      pointList[0] = rect.ul();
      pointList[1] = rect.ur();
      pointList[2] = rect.lr();
      pointList[3] = rect.ll();
      theViewCutter->setEnableFlag(false);
      theViewImageCutter->setEnableFlag(true);
      theViewImageCutter->setPolygon(pointList);
      theViewImageCutter->initialize();
      ossimPropertyEvent evt(theViewImageCutter);
      theViewImageCutter->propagateEventToOutputs(evt);
   }
}
ossimDrect ossimImageViewTransform::getImageToViewBounds(const ossimDrect& imageRect)const
{
    ossimDpt p1;
    ossimDpt p2;
    ossimDpt p3;
    ossimDpt p4;

    imageToView(imageRect.ul(), p1);
    imageToView(imageRect.ur(), p2);
    imageToView(imageRect.lr(), p3);
    imageToView(imageRect.ll(), p4);

    return ossimDrect(p1, p2, p3, p4);
}
Beispiel #7
0
//*****************************************************************************
//  METHOD: ossimDblGrid::initialize()
//  
//  Permits initialization after construction
//  
//*****************************************************************************
void ossimDblGrid::initialize(const ossimDrect&  uv_rect, 
                              const ossimDpt&    spacing,
                              double null_value)
{
   static const char MODULE[] = "ossimDblGrid::initialize()";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   ossimIpt size ((int) (uv_rect.width()/spacing.x)  + 1,
      (int) (uv_rect.height()/spacing.y) + 1);

   initialize(size, uv_rect.ul(), spacing, null_value);

   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " returning...\n";
   return;
}
//**************************************************************************************************
// Converts the local image space rect into bounding view-space rect
//**************************************************************************************************
ossimDrect ossimImageViewProjectionTransform::getImageToViewBounds(const ossimDrect& imageRect)const
{
    // Let base class try:
   ossimDrect result = ossimImageViewTransform::getImageToViewBounds(imageRect);

   // If not successful, compute using input and output geometries:
   if (result.hasNans() && m_imageGeometry.valid() && m_viewGeometry.valid() &&
       m_imageGeometry->hasProjection() && m_viewGeometry->hasProjection())
   {
      ossimGeoPolygon viewClip;
      m_viewGeometry->getProjection()->getGroundClipPoints(viewClip);
      if(viewClip.size())
      {
         std::vector<ossimGpt> imageGpts(4);
         m_imageGeometry->localToWorld(imageRect.ul(), imageGpts[0]);
         m_imageGeometry->localToWorld(imageRect.ur(), imageGpts[1]);
         m_imageGeometry->localToWorld(imageRect.lr(), imageGpts[2]);
         m_imageGeometry->localToWorld(imageRect.ll(), imageGpts[3]);

         const ossimDatum* viewDatum = m_viewGeometry->getProjection()->origin().datum();
         imageGpts[0].changeDatum(viewDatum);
         imageGpts[1].changeDatum(viewDatum);
         imageGpts[2].changeDatum(viewDatum);
         imageGpts[3].changeDatum(viewDatum);
         
         ossimPolyArea2d viewPolyArea(viewClip.getVertexList());
         ossimPolyArea2d imagePolyArea(imageGpts);
         viewPolyArea &= imagePolyArea;
         std::vector<ossimPolygon> visiblePolygons;
         viewPolyArea.getVisiblePolygons(visiblePolygons);
         if(visiblePolygons.size())
         {
            std::vector<ossimDpt> vpts;
            ossim_uint32 idx = 0;
            for(idx=0; idx<visiblePolygons[0].getNumberOfVertices();++idx)
            {
               ossimDpt tempPt;
               ossimGpt gpt(visiblePolygons[0][idx].lat, visiblePolygons[0][idx].lon, 0.0,  viewDatum);
               m_viewGeometry->worldToLocal(gpt, tempPt);
               vpts.push_back(tempPt);
            }
            result = ossimDrect(vpts);
         }
      }
   }
   return result;
}
Beispiel #9
0
//*******************************************************************
// Public Method:
//*******************************************************************
bool ossimDrect::intersects(const ossimDrect& rect) const
{
    if(rect.hasNans() || hasNans())
    {
        return false;
    }
    if (theOrientMode != rect.theOrientMode)
        return false;

    ossim_float64  ulx = ossim::max(rect.ul().x,ul().x);
    ossim_float64  lrx = ossim::min(rect.lr().x,lr().x);
    ossim_float64  uly, lry;
    bool rtn=false;
    if (theOrientMode == OSSIM_LEFT_HANDED)
    {
        uly  = ossim::max(rect.ul().y,ul().y);
        lry  = ossim::min(rect.lr().y,lr().y);
        rtn = ((ulx <= lrx) && (uly <= lry));
    }
    else
    {
        uly  = ossim::max(rect.ll().y,ll().y);
        lry  = ossim::min(rect.ur().y,ur().y);
        rtn = ((ulx <= lrx) && (uly <= lry));
    }

    return (rtn);
}
Beispiel #10
0
/*!****************************************************************************
*  CONSTRUCTOR: ossimDblGrid
*  
*****************************************************************************/
ossimDblGrid::ossimDblGrid(const ossimDrect&  rect, 
                           const ossimDpt&    spacing,
                           double             null_value)
                           :
theGridData   (0),
theMinValue   (OSSIM_DEFAULT_MIN_PIX_DOUBLE),
theMaxValue   (OSSIM_DEFAULT_MAX_PIX_DOUBLE),
theExtrapIsEnabled (true),
theDomainType (CONTINUOUS)
{
   static const char MODULE[] = "ossimDblGrid Constructor";
   if (traceExec())  ossimNotify(ossimNotifyLevel_DEBUG) << MODULE << " entering...\n";

   ossimIpt size ((int) (rect.width()/spacing.x)  + 1,
      (int) (rect.height()/spacing.y) + 1);

   initialize(size, rect.ul(), spacing, null_value);

   if (traceExec())  ossimNotify(ossimNotifyLevel_WARN) << MODULE << " returning...\n";
}
bool ossimAnnotationMultiPolyObject::intersects(const ossimDrect& rect)const
{
    // do the quick checks first
    //
    if(rect.hasNans()) return false;
    if(!rect.intersects(theBoundingRect)) return false;
    if(theMultiPolygon.size()<1) return false;

    for(ossim_uint32 i =0; i < theMultiPolygon.size(); ++i)
    {
        vector<ossimPolygon> result;

        if(theMultiPolygon[i].clipToRect(result, rect))
        {
            return true;
        }
    }

    return false;
}
Beispiel #12
0
//*******************************************************************
// Public Method: ossimDrect::getCode
//*******************************************************************
long ossimDrect::getCode(const ossimDpt& aPoint,
                         const ossimDrect& clipRect)
{
    long result=NONE; // initialize to inside rect

    if( (aPoint.x > clipRect.lr().x) )
        result |= RIGHT;
    else if( (aPoint.x < clipRect.ul().x) )
        result |= LEFT;

    if (clipRect.theOrientMode == OSSIM_LEFT_HANDED)
    {
        if( (aPoint.y < clipRect.ul().y) )
            result |= TOP;
        else if( (aPoint.y > clipRect.lr().y) )
            result |= BOTTOM;
    }
    else
    {
        if( (aPoint.y > clipRect.ul().y) )
            result |= TOP;
        else if( (aPoint.y < clipRect.lr().y) )
            result |= BOTTOM;
    }

    return result;
}
Beispiel #13
0
//*******************************************************************
// Public Method: ossimDrect::completely_within
//*******************************************************************
bool ossimDrect::completely_within(const ossimDrect& rect) const
{
    if(hasNans() || rect.hasNans())
    {
        return false;
    }
    if (theOrientMode != rect.theOrientMode)
        return false;

    /*  --------------
        |     1      |
        | ---------- |
        | |        | |
        | |        | |
        | |   2    | |
        | |        | |
        | |        | |
        | ---------- |
        |            |
        --------------  */

    bool rtn = true;

    if (theUlCorner.x < rect.ul().x)
        rtn = false;

    else if (theLrCorner.x > rect.lr().x)
        rtn = false;

    else if (theOrientMode == OSSIM_LEFT_HANDED)
    {
        if (theUlCorner.y < rect.ul().y)
            rtn = false;

        else if (theLrCorner.y > rect.lr().y)
            rtn = false;
    }

    else
    {
        if (theUlCorner.y > rect.ul().y)
            rtn = false;

        else if (theLrCorner.y < rect.lr().y)
            rtn = false;
    }

    return rtn;
}
Beispiel #14
0
bool ossimPolygon::isInsideEdge(const ossimDpt& pt,
                                const ossimDrect& rect,
                                int edge)const
{
   switch(edge)
   {
   case RECT_LEFT_EDGE:
   {
      return (pt.x>rect.ul().x);
      break;
   }
   case RECT_TOP_EDGE:
   {
      if(rect.orientMode() == OSSIM_LEFT_HANDED)
      {
         return (pt.y > rect.ul().y);
      }
      else
      {
         return (pt.y < rect.ul().y);
      }
      break;
   }
   case RECT_RIGHT_EDGE:
   {
      return (pt.x<rect.lr().x);
      
      break;
   }
   case RECT_BOTTOM_EDGE:
   {
      if(rect.orientMode() == OSSIM_LEFT_HANDED)
      {
         return (pt.y < rect.lr().y);
      }
      else
      {
         return (pt.y > rect.lr().y);
      }
      break;
   }
   }
   return false;
}
Beispiel #15
0
void ossimPolygon::intersectEdge(ossimDpt& result,
                                 const ossimLine& segment,
                                 const ossimDrect& rect,
                                 int edge)
{
   ossimLine edgeLine;
   switch(edge)
   {
   case RECT_LEFT_EDGE:
   {
      edgeLine.theP1 = rect.ll();
      edgeLine.theP2 = rect.ul();
      break;
   }
   case RECT_TOP_EDGE:
   {
      edgeLine.theP1 = rect.ul();
      edgeLine.theP2 = rect.ur();
      break;
   }
   case RECT_RIGHT_EDGE:
   {
      edgeLine.theP1 = rect.ur();
      edgeLine.theP2 = rect.lr();
      break;
   }
   case RECT_BOTTOM_EDGE:
   {
      edgeLine.theP1 = rect.lr();
      edgeLine.theP2 = rect.ll();
      break;
   }
   }
   
   result = segment.intersectInfinite(edgeLine);
}
Beispiel #16
0
void ossimShapeObject::getBoundingRect(ossimDrect& result,
                                       ossimCoordSysOrientMode orient)const
{
   double minx, miny, maxx, maxy;
   
   if(theShape)
   {
      getBounds(minx, miny, maxx, maxy);
      
      if(orient == OSSIM_RIGHT_HANDED)
      {
         result = ossimDrect(minx, maxy, maxx, miny, orient);
      }
      else
      {
         result = ossimDrect(minx, miny, maxx, maxy, orient);         
      }
   }
   else
   {
      result = ossimDrect(0,0,0,0,orient);
      result.makeNan();
   }
}
Beispiel #17
0
//*******************************************************************
// Public Method: ossimDrect::clipToRect
//*******************************************************************
ossimDrect ossimDrect::clipToRect(const ossimDrect& rect)const
{
    ossimDrect result;
    result.makeNan();
    if(rect.hasNans() || hasNans())
    {

        return result;
    }

    if (theOrientMode != rect.theOrientMode)
        return (*this);

    double x0 = ossim::max(rect.ul().x, ul().x);
    double x1 = ossim::min(rect.lr().x, lr().x);
    double y0, y1;

    if (theOrientMode == OSSIM_LEFT_HANDED)
    {
        y0 = ossim::max(rect.ll().y, ll().y);
        y1 = ossim::min(rect.ur().y, ur().y);

        if( (x1 < x0) || (y1 < y0) )
            return result;
        else
            result = ossimDrect(x0, y0, x1, y1, theOrientMode);
    }
    else
    {
        y0 = ossim::max(rect.ll().y,ll().y);
        y1 = ossim::min(rect.ur().y,ur().y);
        if((x0 <= x1) && (y0 <= y1))
        {
            result = ossimDrect(x0, y1, x1, y0, theOrientMode);
        }
    }
    return result;
}
void ossimImageViewTransform::getScaleChangeViewToImage(ossimDpt& result,
        const ossimDrect& viewRect)
{
    result.makeNan();
    if(!viewRect.hasNans())
    {
        ossimDpt iul;
        ossimDpt iur;
        ossimDpt ilr;
        ossimDpt ill;

        imageToView(viewRect.ul(),
                    iul);
        imageToView(viewRect.ur(),
                    iur);
        imageToView(viewRect.lr(),
                    ilr);
        imageToView(viewRect.ll(),
                    ill);

        if(!iul.hasNans()&&
                !iur.hasNans()&&
                !ilr.hasNans()&&
                !ill.hasNans())
        {

            double deltaTop    = (iul - iur).length();
            double deltaBottom = (ill - ilr).length();
            double deltaRight  = (iur - ilr).length();

            double w = viewRect.width();
            double h = viewRect.height();
            result.x = (deltaTop/w + deltaBottom/w)*.5;
            result.y = (deltaRight/h + deltaRight/h)*.5;
        }
    }
}
void ossimImageViewTransform::getScaleChangeImageToView(ossimDpt& result,
        const ossimDrect& imageRect)
{
    result.makeNan();
    if(!imageRect.hasNans())
    {
        ossimDpt vul;
        ossimDpt vur;
        ossimDpt vlr;
        ossimDpt vll;

        imageToView(imageRect.ul(),
                    vul);
        imageToView(imageRect.ur(),
                    vur);
        imageToView(imageRect.lr(),
                    vlr);
        imageToView(imageRect.ll(),
                    vll);

        if(!vul.hasNans()&&
                !vur.hasNans()&&
                !vlr.hasNans()&&
                !vll.hasNans())
        {

            double deltaTop    = (vul - vur).length();
            double deltaBottom = (vll - vlr).length();
            double deltaRight  = (vur - vlr).length();

            double w = imageRect.width();
            double h = imageRect.height();
            result.x = (deltaTop/w + deltaBottom/w)*.5;
            result.y = (deltaRight/h + deltaRight/h)*.5;
        }
    }
}
Beispiel #20
0
void ossimFgdcXmlDoc::getBoundingBox(ossimDrect& rect) const
{
   rect.makeNan();
   
   if (isOpen())
   {
      double ll_lat = 0.0;
      double ll_lon = 0.0;
      double lr_lat = 0.0;
      double lr_lon = 0.0;
      double ul_lat = 0.0;
      double ul_lon = 0.0;
      double ur_lat = 0.0;
      double ur_lon = 0.0;
     
      ossimString xpath = "/metadata/idinfo/spdom/lboundng/leftbc";
      bool result = getPath(xpath, ul_lon);
      if (!result)
      {
         xpath = "/metadata/idinfo/spdom/bounding/westbc";
         result = getPath(xpath, ul_lon);
         m_boundInDegree = true;
      }
      if (result)
      {
         ll_lon = ul_lon;
      }
      
      xpath = "/metadata/idinfo/spdom/lboundng/rightbc";
      result = getPath(xpath, ur_lon);
      if (!result)
      {
         xpath = "/metadata/idinfo/spdom/bounding/eastbc";
         result = getPath(xpath, ur_lon);
         m_boundInDegree = true;
      }
      if (result)
      {
         lr_lon = ur_lon;
      }

      xpath = "/metadata/idinfo/spdom/lboundng/bottombc";
      result = getPath(xpath, ll_lat);
      if (!result)
      {
         xpath = "/metadata/idinfo/spdom/bounding/southbc";
         result = getPath(xpath, ll_lat);
         m_boundInDegree = true;
      }
      if (result)
      {
         lr_lat = ll_lat;
      }

      xpath = "/metadata/idinfo/spdom/lboundng/topbc";
      result = getPath(xpath, ul_lat);
      if (!result)
      {
         xpath = "/metadata/idinfo/spdom/bounding/northbc";
         result = getPath(xpath, ul_lat);
         m_boundInDegree = true;
      }
      if (result)
      {
         ur_lat = ul_lat;
      }
      
      rect = ossimDrect(ossimDpt(ul_lon, ul_lat),
                        ossimDpt(ur_lon, ur_lat),
                        ossimDpt(lr_lon, lr_lat),
                        ossimDpt(ll_lon, ll_lat), OSSIM_RIGHT_HANDED); 
   }
}
bool ossimAnnotationFontObject::intersects(const ossimDrect& rect)const
{
   return rect.intersects(theBoundingRect);
}
Beispiel #22
0
void ossimBuckeyeSensor::setImageRect(const ossimDrect& rect)
{
	theImageClipRect = rect;
	theRefImgPt = rect.midPoint();
}
bool shapefileClip::FindVerticesInImage(SHPHandle hSHP, ossimDrect imgRect, vector<int> &ShapeID)
{
	if (!ShapeID.empty())
		ShapeID.clear();

	if (hSHP == NULL){
		cerr << "Shapefile is not open." << endl
		<< "Line: " << __LINE__ << " " << __FILE__ << endl;
	}

	// Get min and max values for image bounding rectangle.
	double minx, miny, maxx, maxy;
	imgRect.getBounds(minx, miny, maxx, maxy);

	ossimDrect newImgRect;
	newImgRect = ossimDrect(ossimDpt(minx, miny), ossimDpt(maxx, maxy));

	// Determine if image is completely within any of the wvs polygons
	bool allLandFlag = false;
	bool imgCompWithinPoly = false;
	bool onePointInPoly = false;

	SHPObject *obj;
	ossimDrect wvsPolyRect;
	int withinBoundsVertCount = 0;

	// Determine number of polygons in image
	unsigned long int totalPolyCount = 0;

	// loop through each shape in file
	while( obj = SHPReadObject(hSHP, totalPolyCount)){				
		totalPolyCount++;
		wvsPolyRect = ossimDrect(ossimDpt(obj->dfXMin, obj->dfYMin), ossimDpt(obj->dfXMax, obj->dfYMax));

		imgCompWithinPoly = false;
		if (newImgRect.completely_within(wvsPolyRect)){
			imgCompWithinPoly = true;		
			allLandFlag = true;
		}

		if (wvsPolyRect.intersects(newImgRect) || wvsPolyRect.completely_within(newImgRect) || imgCompWithinPoly){
			withinBoundsVertCount = 0;

			if (obj->nParts > 0 && obj->nVertices > 1){
				// loop through vertices of qualified shape
				for (unsigned long int shapeVertex = 0; shapeVertex < (unsigned)obj->nVertices && withinBoundsVertCount==0; ++shapeVertex){	
					// If vertex is within bounding box, then save
					if ((double)obj->padfX[shapeVertex] > minx &&
						(double)obj->padfX[shapeVertex] < maxx &&
						(double)obj->padfY[shapeVertex] > miny &&
						(double)obj->padfY[shapeVertex] < maxy){
							
						++withinBoundsVertCount; 
					}
				}
				
				if (withinBoundsVertCount){ 
					ShapeID.push_back(obj->nShapeId);
				}
				else if (imgCompWithinPoly){		// If bounding box completely within polygon and no vertices found
					ossimPolygon entirePoly;
					for (int j = 0; j < obj->nVertices; ++j)
						entirePoly.addPoint(ossimDpt(obj->padfX[j], obj->padfY[j]));
					
					// Check if image upper left point is within the shapefile polygon
					if (entirePoly.isPointWithin(ossimDpt(minx, miny))){
						onePointInPoly = true;
					}
				}
			}
		}
		
		// Image completely within flag
		imgCompWithinPoly = false;

		SHPDestroyObject(obj);
	}

	SHPDestroyObject(obj);
	obj = NULL;

	// If image boundary is completely within a polygon, but vertices were found within the image boundary, image contains all land
	if (allLandFlag && onePointInPoly && ShapeID.empty()){
		return true;
	}
	else{
		return false;
	}
}
void ossimSpectraboticsRedEdgeModel::setImageRect(const ossimDrect& rect)
{
   theImageClipRect = rect;
   theRefImgPt = rect.midPoint();
}
Beispiel #25
0
void ossimApplanixUtmModel::setImageRect(const ossimDrect& rect)
{
   theImageClipRect = rect;
   theRefImgPt = rect.midPoint();
}
void ossimQuadTreeWarp::getNewQuads(ossimQuadTreeWarpNode* parent,
                                    const ossimDrect& ul,
                                    const ossimDrect& ur,
                                    const ossimDrect& lr,
                                    const ossimDrect& ll,
                                    ossimQuadTreeWarpNode*& ulNode,
                                    ossimQuadTreeWarpNode*& urNode,
                                    ossimQuadTreeWarpNode*& lrNode,
                                    ossimQuadTreeWarpNode*& llNode)
{
   ossimDpt midShift;
   getShift(midShift,
            parent,
            ul.lr());
   
   ossimQuadTreeWarpVertex* midV = new ossimQuadTreeWarpVertex(ul.lr(),
                                                               midShift);

   ulNode = new ossimQuadTreeWarpNode(ul,
                                      parent);
   urNode = new ossimQuadTreeWarpNode(ur,
                                      parent);
   lrNode = new ossimQuadTreeWarpNode(lr,
                                      parent);
   llNode = new ossimQuadTreeWarpNode(ll,
                                      parent);

   midV->addSharedNode(ulNode);
   midV->addSharedNode(urNode);
   midV->addSharedNode(lrNode);
   midV->addSharedNode(llNode);
   
   // get the shared vertices first.  We will add ourself
   // to the pointer list. when we construct
   // the quad nodes.  Note the mid point will be shared
   // by all quads and will be marked as adjustable
   //
   ossimQuadTreeWarpVertex* ulSharedV = getVertex(ul.ul());
   ossimQuadTreeWarpVertex* urSharedV = getVertex(ur.ur());
   ossimQuadTreeWarpVertex* lrSharedV = getVertex(lr.lr());
   ossimQuadTreeWarpVertex* llSharedV = getVertex(ll.ll());
   
   if(!ulSharedV||
      !urSharedV||
      !lrSharedV||
      !llSharedV)
   {
      ossimNotify(ossimNotifyLevel_FATAL) << "FATAL: " << "ossimQuadTreeWarp::split, can't locating shared vertices.  This Shouldn't happen!!!\n";
      return;
   }

   // we know that the midpoint is new and is shared by all quads
   // so we have 2 more to check
   ossimQuadTreeWarpVertex* topSharedV    = getVertex(ul.ur());
   ossimQuadTreeWarpVertex* bottomSharedV = getVertex(lr.ll());

   ossimQuadTreeWarpVertex* leftSharedV   = getVertex(ul.ll());
   ossimQuadTreeWarpVertex* rightSharedV  = getVertex(ur.lr());
   
   ossimDpt tempShift;
   
   if(!topSharedV)
   {
      getShift(tempShift, parent, ul.ur());
      topSharedV = new ossimQuadTreeWarpVertex(ul.ur(),
                                               tempShift);
      theVertexList.push_back(topSharedV);
   }
   if(!bottomSharedV)
   {
      getShift(tempShift, parent, ll.lr());
      bottomSharedV = new ossimQuadTreeWarpVertex(ll.lr(),
                                                  tempShift);
      
      theVertexList.push_back(bottomSharedV);
   }
   if(!leftSharedV)
   {
      getShift(tempShift, parent, ul.ll());
      leftSharedV = new ossimQuadTreeWarpVertex(ul.ll(),
                                               tempShift);
      theVertexList.push_back(leftSharedV);
   }
   if(!rightSharedV)
   {
      getShift(tempShift, parent, ur.lr());
      rightSharedV = new ossimQuadTreeWarpVertex(ur.lr(),
                                               tempShift);
      theVertexList.push_back(rightSharedV);
   }
   theVertexList.push_back(midV);

   topSharedV->addSharedNode(ulNode);
   topSharedV->addSharedNode(urNode);
   
   bottomSharedV->addSharedNode(llNode);
   bottomSharedV->addSharedNode(lrNode);
   leftSharedV->addSharedNode(ulNode);
   leftSharedV->addSharedNode(llNode);
   rightSharedV->addSharedNode(urNode);
   rightSharedV->addSharedNode(lrNode);

   ulSharedV->addSharedNode(ulNode); 
   urSharedV->addSharedNode(urNode);
   lrSharedV->addSharedNode(lrNode);
   llSharedV->addSharedNode(llNode);
  
   ulNode->theUlVertex = ulSharedV;
   ulNode->theUrVertex = topSharedV;
   ulNode->theLrVertex = midV;
   ulNode->theLlVertex = leftSharedV;

   urNode->theUlVertex = topSharedV;
   urNode->theUrVertex = urSharedV;
   urNode->theLrVertex = rightSharedV;
   urNode->theLlVertex = midV;

   lrNode->theUlVertex = midV;
   lrNode->theUrVertex = rightSharedV;
   lrNode->theLrVertex = lrSharedV;
   lrNode->theLlVertex = bottomSharedV;

   llNode->theUlVertex = leftSharedV;
   llNode->theUrVertex = midV;
   llNode->theLrVertex = bottomSharedV;
   llNode->theLlVertex = llSharedV;   
}