Public Member Functions
	ossimRendererSubRectInfo (ossimImageViewTransform *transform=0)

	ossimRendererSubRectInfo (ossimImageViewTransform *transform, const ossimDpt &vul, const ossimDpt &vur, const ossimDpt &vlr, const ossimDpt &vll)

bool	imageHasNans () const

bool	imageIsNan () const

bool	viewHasNans () const

bool	viewIsNan () const

void	splitView (std::vector< ossimRendererSubRectInfo > &result) const

void	transformViewToImage ()

void	transformImageToView ()

bool	tooBig () const

void	roundToInteger ()

void	stretchImageOut (bool enableRound=false)

ossimDrect	getViewRect () const

ossimDrect	getImageRect () const

void	roundImageToInteger ()

void	roundViewToInteger ()

bool	isViewEqual (const ossimRendererSubRectInfo &infoRect) const

bool	isViewEqual (const ossimDrect &viewRect) const

ossimDpt	computeViewToImageScale (const ossimDpt &viewPt, const ossimDpt &delta=ossimDpt(1.0, 1.0)) const

ossimDpt	getAbsValueViewToImageScales () const

ossimDpt	getAbsValueImageToViewScales () const

ossimDpt	computeRoundTripErrorViewPt (const ossimDpt &dpt) const

bool	isViewAPoint () const

bool	isIdentity () const

bool	canBilinearInterpolate (double error) const

ossimDpt	getParametricCenter (const ossimDpt &ul, const ossimDpt &ur, const ossimDpt &lr, const ossimDpt &ll) const

void	getViewMids (ossimDpt &upperMid, ossimDpt &rightMid, ossimDpt &bottomMid, ossimDpt &leftMid, ossimDpt &center) const

void	getImageMids (ossimDpt &upperMid, ossimDpt &rightMid, ossimDpt &bottomMid, ossimDpt &leftMid, ossimDpt &center) const

ossim_uint16	getSplitFlags () const

Private Types
enum	SplitFlag { SPLIT_NONE = 0, UPPER_LEFT_SPLIT_FLAG = 1, UPPER_RIGHT_SPLIT_FLAG = 2, LOWER_RIGHT_SPLIT_FLAG = 4, LOWER_LEFT_SPLIT_FLAG = 8, SPLIT_ALL = UPPER_LEFT_SPLIT_FLAG\|UPPER_RIGHT_SPLIT_FLAG\|LOWER_RIGHT_SPLIT_FLAG\|LOWER_LEFT_SPLIT_FLAG }

Private Member Functions
void	splitHorizontal (std::vector< ossimRendererSubRectInfo > &result) const

void	splitVertical (std::vector< ossimRendererSubRectInfo > &result) const

void	splitAll (std::vector< ossimRendererSubRectInfo > &result) const

Friends
std::ostream &	operator<< (std::ostream &out, const ossimRendererSubRectInfo &rhs)

Detailed Description

Definition at line 157 of file ossimImageRenderer.h.

Member Enumeration Documentation

◆ SplitFlag

enum ossimImageRenderer::ossimRendererSubRectInfo::SplitFlag

private

Enumerator
SPLIT_NONE
UPPER_LEFT_SPLIT_FLAG
UPPER_RIGHT_SPLIT_FLAG
LOWER_RIGHT_SPLIT_FLAG
LOWER_LEFT_SPLIT_FLAG
SPLIT_ALL

Definition at line 159 of file ossimImageRenderer.h.

                   {
       SPLIT_NONE = 0,
       UPPER_LEFT_SPLIT_FLAG  = 1,
       UPPER_RIGHT_SPLIT_FLAG = 2,
       LOWER_RIGHT_SPLIT_FLAG = 4,
       LOWER_LEFT_SPLIT_FLAG  = 8,
       SPLIT_ALL = UPPER_LEFT_SPLIT_FLAG|UPPER_RIGHT_SPLIT_FLAG|LOWER_RIGHT_SPLIT_FLAG|LOWER_LEFT_SPLIT_FLAG
     };

Constructor & Destructor Documentation

◆ ossimRendererSubRectInfo() [1/2]

ossimImageRenderer::ossimRendererSubRectInfo::ossimRendererSubRectInfo ( ossimImageViewTransform * transform = 0 )

inline

Definition at line 345 of file ossimImageRenderer.h.

References m_Ill, m_Ilr, m_ImageToViewScale, m_Iul, m_Iur, m_ViewToImageScale, m_Vll, m_Vlr, m_Vul, m_Vur, ossimIpt::makeNan(), and ossimDpt::makeNan().

 :m_transform(transform),
 m_viewBounds(0)
 {
    m_Vul.makeNan();
    m_Vur.makeNan();
    m_Vlr.makeNan();
    m_Vll.makeNan();
    m_Iul.makeNan();
    m_Iur.makeNan();
    m_Ilr.makeNan();
    m_Ill.makeNan();
    m_ViewToImageScale.makeNan();
    m_ImageToViewScale.makeNan();            
 }

◆ ossimRendererSubRectInfo() [2/2]

ossimImageRenderer::ossimRendererSubRectInfo::ossimRendererSubRectInfo	(	ossimImageViewTransform *	transform,
		const ossimDpt &	vul,
		const ossimDpt &	vur,
		const ossimDpt &	vlr,
		const ossimDpt &	vll
	)

inline

Definition at line 361 of file ossimImageRenderer.h.

References m_Ill, m_Ilr, m_ImageToViewScale, m_Iul, m_Iur, m_ViewToImageScale, and ossimDpt::makeNan().

                          :m_Vul(vul),
                          m_Vur(vur),
                          m_Vlr(vlr),
                          m_Vll(vll),
                          m_transform(transform),
                          m_viewBounds(0)
 {
    m_Iul.makeNan();
    m_Iur.makeNan();
    m_Ilr.makeNan();
    m_Ill.makeNan();
    m_ViewToImageScale.makeNan();
    m_ImageToViewScale.makeNan();            
 }

Member Function Documentation

◆ canBilinearInterpolate()

bool ossimImageRenderer::ossimRendererSubRectInfo::canBilinearInterpolate ( double error ) const

Definition at line 761 of file ossimImageRenderer.cpp.

References ossimDpt::hasNans(), ossimDpt::length(), ossimDpt::x, and ossimDpt::y.

 {
   bool result = false;
 
   // now check point placement
   ossimDpt imageToViewScale = getAbsValueImageToViewScales();
 
   double testScale = imageToViewScale.length();
 
   //  ossimDpt errorUl = transform->getRoundTripErrorView(m_Vul);
   //  ossimDpt errorUr = transform->getRoundTripErrorView(m_Vur);
   //  ossimDpt errorLr = transform->getRoundTripErrorView(m_Vlr);
   //  ossimDpt errorLl = transform->getRoundTripErrorView(m_Vll);
 
   //  if((errorUl.length() > 2 )||
   //     (errorUr.length() > 2 )||
   //     (errorLr.length() > 2 )||
   //     (errorLl.length() > 2))
   //     {
   //        return result;
   //     }
   //  std::cout << "_______________________\n"
   //            << "errorUl: " << errorUl << "\n"
   //            << "errorUr: " << errorUr << "\n"
   //            << "errorLr: " << errorLr << "\n"
   //            << "errorLl: " << errorLl << "\n";
 
   // if there is a large shrink or expansion then just return true.
   // You are probably not worried about error in bilinear interpolation
   //
   if ((testScale > 256) ||
       (testScale < 1.0 / 256.0))
   {
     return true;
   }
 
   if (m_VulScale.hasNans() ||
       m_VurScale.hasNans() ||
       m_VlrScale.hasNans() ||
       m_VllScale.hasNans())
   {
     return result;
   }
 
   //  std::cout << "ulScale: " << m_VulScale << "\n"
   //            << "urScale: " << m_VurScale << "\n"
   //            << "lrScale: " << m_VlrScale << "\n"
   //            << "llScale: " << m_VllScale << "\n";
 
   // check overage power of 2 variance
   // If there is a variance of 1 resolution level
   // then we must split further
   //
   ossim_float64 averageUlScale = m_VulScale.length();
   ossim_float64 averageUrScale = m_VurScale.length();
   ossim_float64 averageLrScale = m_VlrScale.length();
   ossim_float64 averageLlScale = m_VllScale.length();
 
   // std::cout << "_________________________\n";
   // std::cout << log(averageUlScale)/(log(2)) << "\n";
   // std::cout << log(averageUrScale)/(log(2)) << "\n";
   // std::cout << log(averageLrScale)/(log(2)) << "\n";
   // std::cout << log(averageLlScale)/(log(2)) << "\n";
 
   ossim_float64 ratio1 = averageUlScale / averageUrScale;
   ossim_float64 ratio2 = averageUlScale / averageLrScale;
   ossim_float64 ratio3 = averageUlScale / averageLlScale;
 
   // std::cout << "_________________________\n";
   // std::cout << "ratio1: " << ratio1 << "\n";
   // std::cout << "ratio2: " << ratio2 << "\n";
   // std::cout << "ratio3: " << ratio3 << "\n";
 
   // make sure all are within a power of 2 shrink or expand
   // which means the range of each ratio should be
   // between .5 and 2
   result = (((ratio1 < 2) && (ratio1 > 0.5)) &&
             ((ratio2 < 2) && (ratio2 > 0.5)) &&
             ((ratio3 < 2) && (ratio3 > 0.5)));
 
   //result = ((diff1<=2)&&(diff2<=2)&&(diff3<=2));
   //std::cout << "DIFF1: " << diff1 << std::endl;
   //std::cout << "DIFF2: " << diff2 << std::endl;
   //std::cout << "DIFF3: " << diff3 << std::endl;
 
   if (result)
   {
 #if 1
     ossimDpt vUpper, vRight, vBottom, vLeft, vCenter;
     ossimDpt iUpper, iRight, iBottom, iLeft, iCenter;
     ossimDpt testUpper, testRight, testBottom, testLeft, testCenter;
 
     getViewMids(vUpper, vRight, vBottom, vLeft, vCenter);
     getImageMids(iUpper, iRight, iBottom, iLeft, iCenter);
 
     // get the model centers for the mid upper left right bottom
     m_transform->viewToImage(vCenter, testCenter);
 
     if (testCenter.hasNans())
     {
       return false;
     }
 
     m_transform->viewToImage(vUpper, testUpper);
     if (testCenter.hasNans())
     {
       return false;
     }
     m_transform->viewToImage(vRight, testRight);
     if (testRight.hasNans())
     {
       return false;
     }
     m_transform->viewToImage(vBottom, testBottom);
     if (testBottom.hasNans())
     {
       return false;
     }
     m_transform->viewToImage(vLeft, testLeft);
     if (testLeft.hasNans())
     {
       return false;
     }
 
     // now get the model error to bilinear estimate of those points
     double errorCheck1 = (testCenter - iCenter).length();
     double errorCheck2 = (testUpper - iUpper).length();
     double errorCheck3 = (testRight - iRight).length();
     double errorCheck4 = (testBottom - iBottom).length();
     double errorCheck5 = (testLeft - iLeft).length();
     result = ((errorCheck1 < error) &&
               (errorCheck2 < error) &&
               (errorCheck3 < error) &&
               (errorCheck4 < error) &&
               (errorCheck5 < error));
     // std::cout <<"__________________________\n"
     //       << "ERROR1:" <<errorCheck1 << "\n"
     //       << "ERROR2:" <<errorCheck2 << "\n"
     //       << "ERROR3:" <<errorCheck3 << "\n"
     //       << "ERROR4:" <<errorCheck4 << "\n"
     //       << "ERROR5:" <<errorCheck5 << "\n"
     //       << "SENS:  " << error <<  "\n";
 
 #else
     ossimDpt vUpper, vRight, vBottom, vLeft, vCenter;
     ossimDpt iUpper, iRight, iBottom, iLeft, iCenter;
 
     ossimDpt testCenter;
     getViewMids(vUpper, vRight, vBottom, vLeft, vCenter);
     getImageMids(iUpper, iRight, iBottom, iLeft, iCenter);
 
     ossimDpt iFullRes(iCenter.x * imageToViewScale.x,
                       iCenter.y * imageToViewScale.y);
 
     m_transform->viewToImage(vCenter, testCenter);
 
     if (testCenter.hasNans())
     {
       return false;
     }
     ossimDpt testFullRes(testCenter.x * imageToViewScale.x,
                          testCenter.y * imageToViewScale.y);
 
     double errorCheck1 = (testFullRes - iFullRes).length();
 
     iFullRes = ossimDpt(iUpper.x * imageToViewScale.x,
                         iUpper.y * imageToViewScale.y);
 
     m_transform->viewToImage(vUpper, testCenter);
     if (testCenter.hasNans())
     {
       return false;
     }
     testFullRes = ossimDpt(testCenter.x * imageToViewScale.x,
                            testCenter.y * imageToViewScale.y);
     double errorCheck2 = (testFullRes - iFullRes).length();
 
     iFullRes = ossimDpt(iRight.x * imageToViewScale.x,
                         iRight.y * imageToViewScale.y);
 
     m_transform->viewToImage(vRight, testCenter);
     if (testCenter.hasNans())
     {
       return false;
     }
     testFullRes = ossimDpt(testCenter.x * imageToViewScale.x,
                            testCenter.y * imageToViewScale.y);
     double errorCheck3 = (testFullRes - iFullRes).length();
 
     iFullRes = ossimDpt(iBottom.x * imageToViewScale.x,
                         iBottom.y * imageToViewScale.y);
 
     m_transform->viewToImage(vBottom, testCenter);
     if (testCenter.hasNans())
     {
       return false;
     }
     testFullRes = ossimDpt(testCenter.x * imageToViewScale.x,
                            testCenter.y * imageToViewScale.y);
     double errorCheck4 = (testFullRes - iFullRes).length();
 
     iFullRes = ossimDpt(iLeft.x * imageToViewScale.x,
                         iLeft.y * imageToViewScale.y);
 
     m_transform->viewToImage(vLeft, testCenter);
     testFullRes = ossimDpt(testCenter.x * imageToViewScale.x,
                            testCenter.y * imageToViewScale.y);
     double errorCheck5 = (testFullRes - iFullRes).length();
 
     std::cout << "__________________________\n"
               << "ERROR1:" << errorCheck1 << "\n"
               << "ERROR2:" << errorCheck2 << "\n"
               << "ERROR3:" << errorCheck3 << "\n"
               << "ERROR4:" << errorCheck4 << "\n"
               << "ERROR5:" << errorCheck5 << "\n"
               << "SENS:  " << error << "\n";
 
     result = ((errorCheck1 < error) &&
               (errorCheck2 < error) &&
               (errorCheck3 < error) &&
               (errorCheck4 < error) &&
               (errorCheck5 < error));
     // std::cout << "CAN INTERPOLATE? " << result <<"\n";
 #endif
   }
   return result;
 }

◆ computeRoundTripErrorViewPt()

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::computeRoundTripErrorViewPt ( const ossimDpt & dpt ) const

◆ computeViewToImageScale()

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::computeViewToImageScale	(	const ossimDpt &	viewPt,
		const ossimDpt &	delta = `ossimDpt(1.0,1.0)`
	)		const

Definition at line 663 of file ossimImageRenderer.cpp.

References ossimDpt::hasNans(), ossimDpt::isNan(), ossimDpt::length(), ossimDpt::makeNan(), ossimDpt::x, and ossimDpt::y.

 {
   ossimDpt result;
   result.makeNan();
   if(viewPt.hasNans()) return result; 
   ossimDpt ipt;
   m_transform->viewToImage(viewPt, ipt);
 
   if(!ipt.isNan())
   {
 //    ossimDpt delta;
 //    transform->viewToImage(viewPt+ossimDpt(0.5,0.5), delta);
 
 //    delta = delta-ipt;
 //    result.x = delta.length()/std::sqrt(2);
  //   result.y = result.x;
 
     ossimDpt dx;
     ossimDpt dy;
 
     m_transform->viewToImage(viewPt + ossimDpt(delta.x,0.0), dx);
     m_transform->viewToImage(viewPt + ossimDpt(0.0,delta.y), dy);
     dx = dx-ipt;
     dy = dy-ipt;
 
     result.x = dx.length()/fabs(delta.x);
     result.y = dy.length()/fabs(delta.y);
   }
 
   return result;
 }

◆ getAbsValueImageToViewScales()

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::getAbsValueImageToViewScales ( ) const

inline

Definition at line 483 of file ossimImageRenderer.h.

Referenced by ossimImageRenderer::fillTile().

 {
    if(m_ImageToViewScale.hasNans())
    {
       return m_ImageToViewScale;
    }
 
    return ossimDpt(fabs(m_ImageToViewScale.x), fabs(m_ImageToViewScale.y));
 }

◆ getAbsValueViewToImageScales()

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::getAbsValueViewToImageScales ( ) const

inline

Definition at line 474 of file ossimImageRenderer.h.

 {
    if(m_ViewToImageScale.hasNans())
    {
       return m_ImageToViewScale;
    }
    return ossimDpt(fabs(m_ViewToImageScale.x), fabs(m_ViewToImageScale.y));
 }

◆ getImageMids()

void ossimImageRenderer::ossimRendererSubRectInfo::getImageMids	(	ossimDpt &	upperMid,
		ossimDpt &	rightMid,
		ossimDpt &	bottomMid,
		ossimDpt &	leftMid,
		ossimDpt &	center
	)		const

Definition at line 1003 of file ossimImageRenderer.cpp.

References ossimDpt::makeNan().

 {
   if(imageHasNans())
   {
     upperMid.makeNan();
     rightMid.makeNan();
     bottomMid.makeNan();
     leftMid.makeNan();
     center.makeNan();
   }
   else
   {
     upperMid  = (m_Iul + m_Iur)*.5;
     rightMid  = (m_Iur + m_Ilr)*.5;
     bottomMid = (m_Ilr + m_Ill)*.5;
     leftMid   = (m_Iul + m_Ill)*.5;
     center    = (m_Iul + m_Iur + m_Ilr + m_Ill)*.25;
   }
 }

◆ getImageRect()

ossimDrect ossimImageRenderer::ossimRendererSubRectInfo::getImageRect ( ) const

inline

Definition at line 434 of file ossimImageRenderer.h.

 {
    return ossimDrect(m_Iul,
       m_Iur,
       m_Ilr,
       m_Ill);
 }

◆ getParametricCenter()

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::getParametricCenter	(	const ossimDpt &	ul,
		const ossimDpt &	ur,
		const ossimDpt &	lr,
		const ossimDpt &	ll
	)		const

Definition at line 1027 of file ossimImageRenderer.cpp.

 {
   ossimDpt top    = ur - ul;
   ossimDpt bottom = lr - ll;
   
   ossimDpt centerTop = ul + top * .5;
   ossimDpt centerBottom = ll + bottom * .5;
 
   return centerBottom + (centerBottom - centerTop)*.5;
 }

◆ getSplitFlags()

ossim_uint16 ossimImageRenderer::ossimRendererSubRectInfo::getSplitFlags ( ) const

Definition at line 381 of file ossimImageRenderer.cpp.

References ossimDrect::height(), and ossimDrect::width().

 {
   #if 0
    ossim_uint16 result = SPLIT_NONE;
    ossimDrect vRect = getViewRect();
 
    //---
    // Don't allow splits beyond 8x8 pixel. ossim2dBilinearTransform was core dumping with
    // very small rectangles in canBilinearInterpolate(...) method.
    // DRB 05 Dec. 2017
    //---
    if ( imageHasNans()||(vRect.width() < 8 && vRect.height() < 8) )
    {
       return result;
    }
   
    if(imageHasNans())
    {
       if(m_viewBounds->intersects(vRect))
       {
          result = SPLIT_ALL;
       }
       else
       {
          return result;
       }
    }
    /*
      if(result != SPLIT_ALL)
      {
      if(m_ulRoundTripError.hasNans()&&m_urRoundTripError.hasNans()&&
      m_lrRoundTripError.hasNans()&&m_llRoundTripError.hasNans())
      {
      if(m_viewBounds->intersects(getViewRect()))
      {
      result = SPLIT_ALL;
      }
      return result;
      }
      else if(tooBig())
      {
      result = SPLIT_ALL;
      }
      }
 
      if(result != SPLIT_ALL)
      {
      if(m_ulRoundTripError.hasNans()) result |= UPPER_LEFT_SPLIT_FLAG;
      if(m_urRoundTripError.hasNans()) result |= UPPER_RIGHT_SPLIT_FLAG;
      if(m_lrRoundTripError.hasNans()) result |= LOWER_RIGHT_SPLIT_FLAG;
      if(m_llRoundTripError.hasNans()) result |= LOWER_LEFT_SPLIT_FLAG;
      }
    */
    if(result != SPLIT_ALL)
    {
       ossim_float64 bias = m_ImageToViewScale.length();
       if(bias < 1.0) bias = 1.0/bias;
       bias = std::sqrt(bias);
 
       if(bias < 1) bias = 1.0;
 
       // if((m_ulRoundTripError.length() > bias)||
       //    (m_urRoundTripError.length() > bias)||
       //    (m_lrRoundTripError.length() > bias)||
       //    (m_llRoundTripError.length() > bias))
       // {
       // std::cout << "________________\n";
 
       // std::cout << "Bias:  " << bias << "\n"
       //           << "View:  " << getViewRect() << "\n"
       //           << "UL:    " << m_ulRoundTripError.length() << "\n"
       //           << "UR:   " << m_urRoundTripError.length() << "\n"
       //           << "LR:   " << m_lrRoundTripError.length() << "\n"
       //           << "LL:   " << m_llRoundTripError.length() << "\n";
 //     }
       // if(m_ulRoundTripError.length() > sensitivityScale) result |= UPPER_LEFT_SPLIT_FLAG;
       // if(m_urRoundTripError.length() > sensitivityScale) result |= UPPER_RIGHT_SPLIT_FLAG;
       // if(m_lrRoundTripError.length() > sensitivityScale) result |= LOWER_RIGHT_SPLIT_FLAG;
       // if(m_llRoundTripError.length() > sensitivityScale) result |= LOWER_LEFT_SPLIT_FLAG;
       // std::cout << result << " == " << SPLIT_ALL << "\n";
 
       if((result!=SPLIT_ALL)&&!canBilinearInterpolate(bias))
       {
          // std::cout << "TESTING BILINEAR!!!!\n";
          result = SPLIT_ALL;
 
       }
       else
       {
          // std::cout << "CAN BILINEAR!!!!\n";
       }
    }
 
    return result;
 #else
   ossim_uint16 result = SPLIT_NONE;
   ossimDrect vRect = getViewRect();
 
   if(imageHasNans()||tooBig())
   {
      if(m_viewBounds->intersects(getViewRect()))
      {
       result = SPLIT_ALL;
      }
      else
      {
         return result;
      }
   }
   /*
   if(result != SPLIT_ALL)
   {
     if(m_ulRoundTripError.hasNans()&&m_urRoundTripError.hasNans()&&
         m_lrRoundTripError.hasNans()&&m_llRoundTripError.hasNans())
     {
       if(m_viewBounds->intersects(getViewRect()))
       {
         result = SPLIT_ALL;
       }
       return result;
     }
     else if(tooBig())
     {
       result = SPLIT_ALL;
     }
   }
 
   if(result != SPLIT_ALL)
   {
     if(m_ulRoundTripError.hasNans()) result |= UPPER_LEFT_SPLIT_FLAG;
     if(m_urRoundTripError.hasNans()) result |= UPPER_RIGHT_SPLIT_FLAG;
     if(m_lrRoundTripError.hasNans()) result |= LOWER_RIGHT_SPLIT_FLAG;
     if(m_llRoundTripError.hasNans()) result |= LOWER_LEFT_SPLIT_FLAG;
   }
 */
   if(result != SPLIT_ALL)
   {
     ossim_float64 sensitivityScale = m_ImageToViewScale.length();
     //std::cout << sensitivityScale << std::endl;
     if(sensitivityScale < 1.0) sensitivityScale = 1.0/sensitivityScale;
 
 
      // if((m_ulRoundTripError.length() > sensitivityScale)||
      //    (m_urRoundTripError.length() > sensitivityScale)||
      //    (m_lrRoundTripError.length() > sensitivityScale)||
      //    (m_llRoundTripError.length() > sensitivityScale))
      // {
      //   std::cout << "________________\n";
 
      //   std::cout << "Sens:  " << sensitivityScale << "\n"
      //             << "View:  " << getViewRect() << "\n"
      //             << "UL:    " << m_ulRoundTripError.length() << "\n"
      //             << "UR:   " << m_urRoundTripError.length() << "\n"
      //             << "LR:   " << m_lrRoundTripError.length() << "\n"
      //             << "LL:   " << m_llRoundTripError.length() << "\n";
      // }
    // if(m_ulRoundTripError.length() > sensitivityScale) result |= UPPER_LEFT_SPLIT_FLAG;
    // if(m_urRoundTripError.length() > sensitivityScale) result |= UPPER_RIGHT_SPLIT_FLAG;
    // if(m_lrRoundTripError.length() > sensitivityScale) result |= LOWER_RIGHT_SPLIT_FLAG;
    // if(m_llRoundTripError.length() > sensitivityScale) result |= LOWER_LEFT_SPLIT_FLAG;
        // std::cout << result << " == " << SPLIT_ALL << "\n";
 
     if((result!=SPLIT_ALL)&&!canBilinearInterpolate(sensitivityScale))
     {
       // std::cout << "TESTING BILINEAR!!!!\n";
       result = SPLIT_ALL;
 
     }
     else
     {
       // std::cout << "CAN BILINEAR!!!!\n";
     }
   }
 
   return result;
 #endif
 }

◆ getViewMids()

void ossimImageRenderer::ossimRendererSubRectInfo::getViewMids	(	ossimDpt &	upperMid,
		ossimDpt &	rightMid,
		ossimDpt &	bottomMid,
		ossimDpt &	leftMid,
		ossimDpt &	center
	)		const

Definition at line 989 of file ossimImageRenderer.cpp.

 {
   
   upperMid  = (m_Vul + m_Vur)*.5;
   rightMid  = (m_Vur + m_Vlr)*.5;
   bottomMid = (m_Vlr + m_Vll)*.5;
   leftMid   = (m_Vul + m_Vll)*.5;
   center    = (m_Vul + m_Vur + m_Vlr + m_Vll)*.25;
 }

◆ getViewRect()

ossimDrect ossimImageRenderer::ossimRendererSubRectInfo::getViewRect ( ) const

inline

Definition at line 426 of file ossimImageRenderer.h.

Referenced by ossimImageRenderer::fillTile(), and ossimImageRenderer::recursiveResample().

 {
    return ossimDrect(m_Vul,
       m_Vur,
       m_Vlr,
       m_Vll);            
 }

◆ imageHasNans()

bool ossimImageRenderer::ossimRendererSubRectInfo::imageHasNans ( ) const

inline

Definition at line 381 of file ossimImageRenderer.h.

Referenced by ossimImageRenderer::fillTile(), and ossimImageRenderer::recursiveResample().

 {
    return ( m_Iul.hasNans()||
       m_Iur.hasNans()||
       m_Ilr.hasNans()||
       m_Ill.hasNans());
 }

◆ imageIsNan()

bool ossimImageRenderer::ossimRendererSubRectInfo::imageIsNan ( ) const

inline

Definition at line 389 of file ossimImageRenderer.h.

Referenced by ossimImageRenderer::recursiveResample().

 {
    return ( m_Iul.hasNans()&&
       m_Iur.hasNans()&&
       m_Ilr.hasNans()&&
       m_Ill.hasNans());
 }

◆ isIdentity()

bool ossimImageRenderer::ossimRendererSubRectInfo::isIdentity ( ) const

Definition at line 726 of file ossimImageRenderer.cpp.

References FLT_EPSILON.

 {
 //    ossimDpt deltaP1P2 = m_Iul - m_Iur;
 //    ossimDpt deltaP1P3 = m_Iul - m_Ill;
    
 //    ossimDpt deltaViewP1P2 = m_Vul - m_Vur;
 //    ossimDpt deltaViewP1P3 = m_Vul - m_Vll;
    
 //    bool horizontalSigns = ossimGetSign(deltaP1P2.x)==ossimGetSign(deltaViewP1P2.x);
 //    bool verticalSigns   = ossimGetSign(deltaP1P3.y)==ossimGetSign(deltaViewP1P3.y);
 
 //    // check first to see if any horizontal or vertical flipping
 //    //
 //    if(horizontalSigns && verticalSigns)
 //    {
 //       // check scales to see if they are 1
 //       if(fabs(1-m_ViewToImageScale.x) <= FLT_EPSILON &&
 //          fabs(1-m_ViewToImageScale.y) <= FLT_EPSILON)
 //       {
 //          return true;
 //       }
 //    }
 
     double iulDelta = (m_Iul-m_Vul).length();
     double iurDelta = (m_Iur-m_Vur).length();
     double ilrDelta = (m_Ilr-m_Vlr).length();
     double illDelta = (m_Ill-m_Vll).length();
 
     return ((iulDelta <= FLT_EPSILON)&&
             (iurDelta <= FLT_EPSILON)&&
             (ilrDelta <= FLT_EPSILON)&&
             (illDelta <= FLT_EPSILON));
 }

◆ isViewAPoint()

bool ossimImageRenderer::ossimRendererSubRectInfo::isViewAPoint ( ) const

inline

Definition at line 493 of file ossimImageRenderer.h.

 {
    return ((m_Vul == m_Vur)&&
       (m_Vul == m_Vlr)&&
       (m_Vul == m_Vll));
 }

◆ isViewEqual() [1/2]

bool ossimImageRenderer::ossimRendererSubRectInfo::isViewEqual ( const ossimRendererSubRectInfo & infoRect ) const

inline

Definition at line 458 of file ossimImageRenderer.h.

References m_Vll, m_Vlr, m_Vul, and m_Vur.

 {
    return ( (m_Vul == infoRect.m_Vul)&&
       (m_Vur == infoRect.m_Vur)&&
       (m_Vlr == infoRect.m_Vlr)&&
       (m_Vll == infoRect.m_Vll));
 }

◆ isViewEqual() [2/2]

bool ossimImageRenderer::ossimRendererSubRectInfo::isViewEqual ( const ossimDrect & viewRect ) const

inline

Definition at line 466 of file ossimImageRenderer.h.

References ossimDrect::ll(), ossimDrect::lr(), ossimDrect::ul(), and ossimDrect::ur().

 {
    return ( (m_Vul == viewRect.ul())&&
       (m_Vur == viewRect.ur())&&
       (m_Vlr == viewRect.lr())&&
       (m_Vll == viewRect.ll()));
 }

◆ roundImageToInteger()

void ossimImageRenderer::ossimRendererSubRectInfo::roundImageToInteger ( )

inline

Definition at line 442 of file ossimImageRenderer.h.

 {
    m_Iul = ossimIpt(m_Iul);
    m_Iur = ossimIpt(m_Iur);
    m_Ilr = ossimIpt(m_Ilr);
    m_Ill = ossimIpt(m_Ill);
 }

◆ roundToInteger()

void ossimImageRenderer::ossimRendererSubRectInfo::roundToInteger ( )

inline

Definition at line 413 of file ossimImageRenderer.h.

 {
    m_Iul = ossimIpt(m_Iul);
    m_Iur = ossimIpt(m_Iur);
    m_Ilr = ossimIpt(m_Ilr);
    m_Ill = ossimIpt(m_Ill);
 
    m_Vul = ossimIpt(m_Vul);
    m_Vur = ossimIpt(m_Vur);
    m_Vlr = ossimIpt(m_Vlr);
    m_Vll = ossimIpt(m_Vll);
 }

◆ roundViewToInteger()

void ossimImageRenderer::ossimRendererSubRectInfo::roundViewToInteger ( )

inline

Definition at line 450 of file ossimImageRenderer.h.

 {
    m_Vul = ossimIpt(m_Vul);
    m_Vur = ossimIpt(m_Vur);
    m_Vlr = ossimIpt(m_Vlr);
    m_Vll = ossimIpt(m_Vll);
 }

◆ splitAll()

void ossimImageRenderer::ossimRendererSubRectInfo::splitAll ( std::vector< ossimRendererSubRectInfo > & result ) const

private

Definition at line 174 of file ossimImageRenderer.cpp.

References ossimIrect::height(), ossimIrect::ll(), ossimIrect::lr(), m_viewBounds, ossimIrect::ul(), ossimIrect::ur(), ossimIrect::width(), ossimIpt::x, and ossimIpt::y.

 {
    //std::cout << "FULL Split\n" << std::endl;
    // let splitAll for now.  We can still optimize but will do that later
    ossimIrect tempUlRect;
    ossimIrect tempUrRect;
    ossimIrect tempLrRect;
    ossimIrect tempLlRect;
    ossimIrect vrect(m_Vul,
                     m_Vur,
                     m_Vlr,
                     m_Vll);
    ossim_int32 w  = vrect.width();
    ossim_int32 h  = vrect.height();
    ossim_int32 w2 = w>>1;
    ossim_int32 h2 = h>>1;
 
    tempUlRect = ossimIrect(m_Vul.x,
                            m_Vul.y,
                            m_Vul.x + (w2 - 1),
                            m_Vul.y + (h2 - 1));
   
    tempUrRect = ossimIrect(tempUlRect.ur().x+1,
                            m_Vul.y,
                            m_Vur.x,
                            m_Vul.y + (h2 - 1));
   
    tempLrRect = ossimIrect(tempUlRect.lr().x,
                            tempUlRect.lr().y+1,
                            m_Vlr.x,
                            m_Vlr.y);
   
    tempLlRect = ossimIrect(m_Vul.x,
                            tempUlRect.ll().y+1,
                            tempLrRect.ul().x,
                            tempLrRect.ll().y);
 
 //  std::cout << "VR: " << vrect.width() << ", " << vrect.height() << "\n"
 //            << "UL: " << tempUlRect.width() << ", " << tempUlRect.height() << "\n"
 //            << "UR: " << tempUrRect.width() << ", " << tempUrRect.height() << "\n"
 //            << "LR: " << tempLrRect.width() << ", " << tempLrRect.height() << "\n"
 //            << "LL: " << tempLlRect.width() << ", " << tempLlRect.height() << "\n";
 
    ossimRendererSubRectInfo ul(m_transform.get(),tempUlRect.ul(), tempUlRect.ur(),tempUlRect.lr(), tempUlRect.ll());
    ossimRendererSubRectInfo ur(m_transform.get(),tempUrRect.ul(), tempUrRect.ur(),tempUrRect.lr(), tempUrRect.ll());
    ossimRendererSubRectInfo lr(m_transform.get(),tempLrRect.ul(), tempLrRect.ur(),tempLrRect.lr(), tempLrRect.ll());
    ossimRendererSubRectInfo ll(m_transform.get(),tempLlRect.ul(), tempLlRect.ur(),tempLlRect.lr(), tempLlRect.ll());
 
    ul.m_viewBounds = m_viewBounds;
    ur.m_viewBounds = m_viewBounds;
    lr.m_viewBounds = m_viewBounds;
    ll.m_viewBounds = m_viewBounds;
 
    ul.transformViewToImage();
    ur.transformViewToImage();
    lr.transformViewToImage();
    ll.transformViewToImage();
 
    if(ul.imageIsNan())
    {
       if(ul.m_viewBounds->intersects(ul.getViewRect()))
       {
          result.push_back(ul);
       }
    }
    else
    {
       result.push_back(ul);
    }
    if(ur.imageIsNan())
    {
       if(ur.m_viewBounds->intersects(ur.getViewRect()))
       {
          result.push_back(ur);
       }
    }
    else
    {
       result.push_back(ur);
    }
    if(lr.imageIsNan())
    {
       if(lr.m_viewBounds->intersects(lr.getViewRect()))
       {
          result.push_back(lr);
       }
    }
    else
    {
       result.push_back(lr);
    }
    if(ll.imageIsNan())
    {
       if(ll.m_viewBounds->intersects(ll.getViewRect()))
       {
          result.push_back(ll);
       }
    }
    else
    {
       result.push_back(ll);
    }
 }

◆ splitHorizontal()

void ossimImageRenderer::ossimRendererSubRectInfo::splitHorizontal ( std::vector< ossimRendererSubRectInfo > & result ) const

private

Definition at line 51 of file ossimImageRenderer.cpp.

References ossimRefPtr< T >::get(), ossimIrect::ll(), ossimIrect::lr(), m_transform, m_viewBounds, m_Vll, m_Vlr, m_Vul, m_Vur, ossimIrect::ul(), ossimIrect::ur(), ossimIrect::width(), ossimIpt::x, and ossimIpt::y.

 {
    ossimIrect vrect(m_Vul,
                     m_Vur,
                     m_Vlr,
                     m_Vll);
    ossim_int32 w  = vrect.width();
    // ossim_int32 h  = vrect.height();
    ossim_int32 w2 = w>>1;
    ossimIrect tempLeftRect(m_Vul.x, 
                            m_Vul.y, 
                            m_Vul.x+w2-1, 
                            m_Vlr.y);
    ossimIrect tempRightRect(tempLeftRect.ur().x+1, 
                             m_Vul.y, 
                             m_Vur.x, 
                             m_Vlr.y);
 
 
    ossimRendererSubRectInfo left(m_transform.get());
    ossimRendererSubRectInfo right(m_transform.get());
 
    left.m_viewBounds = m_viewBounds;
    right.m_viewBounds = m_viewBounds;
 
    left.m_Vul = tempLeftRect.ul();
    left.m_Vur = tempLeftRect.ur();
    left.m_Vlr = tempLeftRect.lr();
    left.m_Vll = tempLeftRect.ll();
 
    right.m_Vul = tempRightRect.ul();
    right.m_Vur = tempRightRect.ur();
    right.m_Vlr = tempRightRect.lr();
    right.m_Vll = tempRightRect.ll();
 
    left.transformViewToImage();
    right.transformViewToImage();
 
    if(left.imageIsNan())
    {
       if(left.m_viewBounds->intersects(left.getViewRect()))
       {
          result.push_back(left);
       }
    }
    else
    {
       result.push_back(left);
    }
    if(right.imageIsNan())
    {
       if(right.m_viewBounds->intersects(right.getViewRect()))
       {
          result.push_back(right);
       }
    }
    else
    {
       result.push_back(right);
    }
 }

◆ splitVertical()

void ossimImageRenderer::ossimRendererSubRectInfo::splitVertical ( std::vector< ossimRendererSubRectInfo > & result ) const

private

Definition at line 113 of file ossimImageRenderer.cpp.

References ossimIrect::height(), ossimIrect::ll(), ossimIrect::lr(), m_viewBounds, ossimIrect::ul(), ossimIrect::ur(), and ossimIpt::y.

 {
    ossimIrect vrect(m_Vul,
                     m_Vur,
                     m_Vlr,
                     m_Vll);
    // ossim_int32 w  = vrect.width();
    ossim_int32 h  = vrect.height();
    ossim_int32 h2 = h>>1;
    ossimIrect tempTopRect(m_Vul.x, 
                           m_Vul.y, 
                           m_Vlr.x, 
                           m_Vul.y+h2-1);
    ossimIrect tempBottomRect(m_Vul.x, 
                              tempTopRect.lr().y+1, 
                              m_Vlr.x, 
                              m_Vlr.y);
 
    ossimRendererSubRectInfo top(m_transform.get());
    ossimRendererSubRectInfo bottom(m_transform.get());
 
    top.m_viewBounds    = m_viewBounds;
    bottom.m_viewBounds = m_viewBounds;
 
    top.m_Vul = tempTopRect.ul();
    top.m_Vur = tempTopRect.ur();
    top.m_Vlr = tempTopRect.lr();
    top.m_Vll = tempTopRect.ll();
 
    bottom.m_Vul = tempBottomRect.ul();
    bottom.m_Vur = tempBottomRect.ur();
    bottom.m_Vlr = tempBottomRect.lr();
    bottom.m_Vll = tempBottomRect.ll();
 
    top.transformViewToImage();
    bottom.transformViewToImage();
 
    if(top.imageIsNan())
    {
       if(top.m_viewBounds->intersects(top.getViewRect()))
       {
          result.push_back(top);
       }
    }
    else
    {
       result.push_back(top);
    }
    if(bottom.imageIsNan())
    {
       if(bottom.m_viewBounds->intersects(bottom.getViewRect()))
       {
          result.push_back(bottom);
       }
    }
    else
    {
       result.push_back(bottom);
    }
 }

◆ splitView()

void ossimImageRenderer::ossimRendererSubRectInfo::splitView ( std::vector< ossimRendererSubRectInfo > & result ) const

Definition at line 278 of file ossimImageRenderer.cpp.

References ossimIrect::height(), m_viewBounds, and ossimIrect::width().

Referenced by ossimImageRenderer::recursiveResample().

 {
    ossim_uint16 splitFlags = getSplitFlags();
    if(!splitFlags)
    {
       return;
    }
 
   
    // just do horizontal split for test
    ossimIrect vrect(m_Vul,
                     m_Vur,
                     m_Vlr,
                     m_Vll);
    ossim_int32 w  = vrect.width();
    ossim_int32 h  = vrect.height();
    ossim_int32 w2 = w>>1;
    ossim_int32 h2 = h>>1;
    
    if((w2 <2)&&(h2<2))
    {
       ossimRendererSubRectInfo rect(m_transform.get(),m_Vul, 
                                     m_Vul, 
                                     m_Vul, 
                                     m_Vul);
       rect.m_viewBounds = m_viewBounds;
       rect.transformViewToImage();
 
       if(rect.imageHasNans())
       {
         if(rect.m_viewBounds->intersects(rect.getViewRect()))
         {
             result.push_back(rect);
         }
       }
    }
    // horizontal split if only the upper left and lower left 
    // vertices need splitting 
    else if((splitFlags==(UPPER_LEFT_SPLIT_FLAG|LOWER_LEFT_SPLIT_FLAG))||
            (splitFlags==(UPPER_RIGHT_SPLIT_FLAG|LOWER_RIGHT_SPLIT_FLAG)))
    {
       // std::cout << "Horizontal Split\n" << std::endl;    
       if(w > 1)
       {
          splitHorizontal(result);
       }
    }  
    // check vertical only split
    else if((splitFlags==(UPPER_LEFT_SPLIT_FLAG|UPPER_RIGHT_SPLIT_FLAG))||
            (splitFlags==(LOWER_RIGHT_SPLIT_FLAG|LOWER_LEFT_SPLIT_FLAG)))
    {
       //std::cout << "Vertical Split\n" << std::endl;
 
       if(h>1)
       {
          splitVertical(result);
       }
    }
    else//if((w>1)&&(h>1)&&(splitFlags))
    {
       if((w<2)&&(h>1))
       {
          splitVertical(result);
       }
       else if((w>1)&&(h<2))
       {
          splitHorizontal(result);
       }
       else
       {
          splitAll(result);
       }
    }
 }

◆ stretchImageOut()

void ossimImageRenderer::ossimRendererSubRectInfo::stretchImageOut ( bool enableRound = false )

Definition at line 696 of file ossimImageRenderer.cpp.

References ossimDpt::length().

 {
    ossimDpt topDelta    = m_Iur - m_Iul;
    ossimDpt rightDelta  = m_Ilr - m_Iur;
    ossimDpt bottomDelta = m_Ill - m_Ilr;
    ossimDpt leftDelta   = m_Iul - m_Ill;
 
    topDelta = topDelta*(1.0/topDelta.length());
    rightDelta = rightDelta*(1.0/rightDelta.length());
    bottomDelta = bottomDelta*(1.0/bottomDelta.length());
    leftDelta = leftDelta*(1.0/leftDelta.length());
 
    m_Iul = m_Iul + ((leftDelta - topDelta)*.5);
    m_Iur = m_Iur + ((topDelta - rightDelta)*.5);
    m_Ilr = m_Ilr + ((rightDelta - bottomDelta)*.5);
    m_Ill = m_Ill + ((bottomDelta - leftDelta)*.5);
 
    if(enableRound)
    {
       m_Iul = ossimIpt(ossim::round<int>(m_Iul.x),
                         ossim::round<int>(m_Iul.y));
       m_Iur = ossimIpt(ossim::round<int>(m_Iur.x),
                         ossim::round<int>(m_Iur.y));
       m_Ilr = ossimIpt(ossim::round<int>(m_Ilr.x),
                         ossim::round<int>(m_Ilr.y));
       m_Ill = ossimIpt(ossim::round<int>(m_Ill.x),
                         ossim::round<int>(m_Ill.y));
    }
 }

◆ tooBig()

bool ossimImageRenderer::ossimRendererSubRectInfo::tooBig ( ) const

Definition at line 374 of file ossimImageRenderer.cpp.

References ossimDrect::height(), and ossimDrect::width().

 {
   ossimDrect vRect = getViewRect();
 
   return ((vRect.width() > 32) || (vRect.height() > 32));
 }

◆ transformImageToView()

void ossimImageRenderer::ossimRendererSubRectInfo::transformImageToView ( )

Definition at line 353 of file ossimImageRenderer.cpp.

 {
    ossimDpt vul;
    ossimDpt vur;
    ossimDpt vlr;
    ossimDpt vll;
    m_transform->imageToView(m_Iul,
                           vul);
    m_transform->imageToView(m_Iur,
                           vur);
    m_transform->imageToView(m_Ilr,
                           vlr);
    m_transform->imageToView(m_Ill,
                           vll);
    
    m_Vul = vul;
    m_Vur = vur;
    m_Vlr = vlr;
    m_Vll = vll;
 }

◆ transformViewToImage()

void ossimImageRenderer::ossimRendererSubRectInfo::transformViewToImage ( )

Definition at line 559 of file ossimImageRenderer.cpp.

References FLT_EPSILON, ossimDrect::height(), ossimDpt::length(), n, and ossimDrect::width().

 {
 //  std::cout << "TRANSFORM VIEW TO IMAGE!!!!!!!!!!!!!!\n";
 
    ossimDrect vrect = getViewRect();
    ossim_float64 w = vrect.width() - 1; // subtract 1 to prevent core dump in full-earth view rect
    ossim_float64 h = vrect.height();
 
    m_transform->viewToImage(m_Vul, m_Iul);
    m_transform->viewToImage(m_Vur, m_Iur);
    m_transform->viewToImage(m_Vlr, m_Ilr);
    m_transform->viewToImage(m_Vll, m_Ill);
 
 //  m_ulRoundTripError = m_transform->getRoundTripErrorView(m_Vul);
 //  m_urRoundTripError = m_transform->getRoundTripErrorView(m_Vur);
 //  m_lrRoundTripError = m_transform->getRoundTripErrorView(m_Vlr);
 //  m_llRoundTripError = m_transform->getRoundTripErrorView(m_Vll);
 
 #if 1
    m_VulScale = computeViewToImageScale(m_Vul, ossimDpt( w, h));
    m_VurScale = computeViewToImageScale(m_Vur, ossimDpt(-w, h));
    m_VlrScale = computeViewToImageScale(m_Vlr, ossimDpt(-w,-h));
    m_VllScale = computeViewToImageScale(m_Vll, ossimDpt( w,-h));
 
    ossim_int32 n = 0;
    m_ViewToImageScale.x = 0.0;
    m_ViewToImageScale.y = 0.0;
 
    if(!m_VulScale.hasNans())
    {
       m_ViewToImageScale += m_VulScale; 
       ++n;
    }
    if(!m_VurScale.hasNans())
    {
       m_ViewToImageScale += m_VurScale; 
       ++n;
    }
    if(!m_VlrScale.hasNans())
    {
       m_ViewToImageScale += m_VlrScale; 
       ++n;
    }
    if(!m_VllScale.hasNans())
    {
       m_ViewToImageScale += m_VllScale; 
       ++n;
    }
    if(!n)
    {
       m_ViewToImageScale.makeNan();
    }
    else
    {
       m_ViewToImageScale.x/=n;
       m_ViewToImageScale.y/=n;
    }
 
 #else
    {
       m_ViewToImageScale = ossimDpt(1.0, 1.0);
       
       ossimDpt topDelta    = m_Iur - m_Iul;
       ossimDpt rightDelta  = m_Ilr - m_Iur;
       ossimDpt bottomDelta = m_Ill - m_Ilr;
       ossimDpt leftDelta   = m_Iul - m_Ill;
       
       double topLen    = topDelta.length();
       double bottomLen = bottomDelta.length();
       double rightLen  = rightDelta.length();
       double leftLen   = leftDelta.length();
       
       double averageHoriz = ((topLen)  + (bottomLen))*.5;
       double averageVert  = ((leftLen) + (rightLen))*.5;
       
       ossimDpt deltaViewP1P2 = m_Vul - m_Vur;
       ossimDpt deltaViewP1P3 = m_Vul - m_Vll;
       
       double lengthViewP1P2 = deltaViewP1P2.length();//+1;
       double lengthViewP1P3 = deltaViewP1P3.length();//+1;
 
       if(lengthViewP1P2 > FLT_EPSILON)
          m_ViewToImageScale.x = averageHoriz/lengthViewP1P2;
       else
          m_ViewToImageScale.makeNan();
       if(lengthViewP1P3 > FLT_EPSILON)
          m_ViewToImageScale.y = averageVert/lengthViewP1P3;
       else
          m_ViewToImageScale.makeNan();
    }
 #endif
 
    //std::cout << m_ViewToImageScale << std::endl;
    if(!m_ViewToImageScale.hasNans())
    {
       m_ImageToViewScale.x = 1.0/m_ViewToImageScale.x;
       m_ImageToViewScale.y = 1.0/m_ViewToImageScale.y;
    }
    else
    {
       m_ImageToViewScale.makeNan();
    }
 }

◆ viewHasNans()

bool ossimImageRenderer::ossimRendererSubRectInfo::viewHasNans ( ) const

inline

Definition at line 397 of file ossimImageRenderer.h.

 {
    return ( m_Vul.hasNans()||
       m_Vur.hasNans()||
       m_Vlr.hasNans()||
       m_Vll.hasNans());
 }

◆ viewIsNan()

bool ossimImageRenderer::ossimRendererSubRectInfo::viewIsNan ( ) const

inline

Definition at line 405 of file ossimImageRenderer.h.

 {
    return ( m_Vul.hasNans()&&
       m_Vur.hasNans()&&
       m_Vlr.hasNans()&&
       m_Vll.hasNans());
 }

Friends And Related Function Documentation

◆ operator<<

std::ostream& operator<<	(	std::ostream &	out,
		const ossimRendererSubRectInfo &	rhs
	)

friend

Definition at line 168 of file ossimImageRenderer.h.

       {
          return out << "vul:   " << rhs.m_Vul << endl
             << "vur:   " << rhs.m_Vur << endl
             << "vlr:   " << rhs.m_Vlr << endl
             << "vll:   " << rhs.m_Vll << endl
             << "iul:   " << rhs.m_Iul << endl
             << "iur:   " << rhs.m_Iur << endl
             << "ilr:   " << rhs.m_Ilr << endl
             << "ill:   " << rhs.m_Ill << endl
             << "scale: " << rhs.m_ViewToImageScale << endl;
 
       }

Member Data Documentation

◆ m_Ill

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_Ill

Definition at line 238 of file ossimImageRenderer.h.

Referenced by ossimImageRenderer::fillTile(), and ossimRendererSubRectInfo().

◆ m_Ilr

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_Ilr

Definition at line 237 of file ossimImageRenderer.h.

Referenced by ossimImageRenderer::fillTile(), and ossimRendererSubRectInfo().

◆ m_ImageToViewScale

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_ImageToViewScale

Definition at line 246 of file ossimImageRenderer.h.

Referenced by ossimRendererSubRectInfo().

◆ m_Iul

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_Iul

Definition at line 235 of file ossimImageRenderer.h.

Referenced by ossimImageRenderer::fillTile(), and ossimRendererSubRectInfo().

◆ m_Iur

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_Iur

Definition at line 236 of file ossimImageRenderer.h.

Referenced by ossimImageRenderer::fillTile(), and ossimRendererSubRectInfo().

◆ m_llRoundTripError

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_llRoundTripError

Definition at line 257 of file ossimImageRenderer.h.

◆ m_lrRoundTripError

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_lrRoundTripError

Definition at line 256 of file ossimImageRenderer.h.

◆ m_transform

ossimRefPtr<ossimImageViewTransform> ossimImageRenderer::ossimRendererSubRectInfo::m_transform

mutable

Definition at line 259 of file ossimImageRenderer.h.

Referenced by splitHorizontal().

◆ m_ulRoundTripError

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_ulRoundTripError

Definition at line 254 of file ossimImageRenderer.h.

◆ m_urRoundTripError

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_urRoundTripError

Definition at line 255 of file ossimImageRenderer.h.

◆ m_viewBounds

const ossimPolyArea2d* ossimImageRenderer::ossimRendererSubRectInfo::m_viewBounds

mutable

Definition at line 260 of file ossimImageRenderer.h.

Referenced by splitAll(), splitHorizontal(), splitVertical(), and splitView().

◆ m_ViewToImageScale

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_ViewToImageScale

Definition at line 245 of file ossimImageRenderer.h.

Referenced by ossimRendererSubRectInfo().

◆ m_Vll

ossimIpt ossimImageRenderer::ossimRendererSubRectInfo::m_Vll

Definition at line 243 of file ossimImageRenderer.h.

Referenced by isViewEqual(), ossimRendererSubRectInfo(), and splitHorizontal().

◆ m_VllScale

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_VllScale

Definition at line 252 of file ossimImageRenderer.h.

◆ m_Vlr

ossimIpt ossimImageRenderer::ossimRendererSubRectInfo::m_Vlr

Definition at line 242 of file ossimImageRenderer.h.

Referenced by isViewEqual(), ossimRendererSubRectInfo(), and splitHorizontal().

◆ m_VlrScale

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_VlrScale

Definition at line 251 of file ossimImageRenderer.h.

◆ m_Vul

ossimIpt ossimImageRenderer::ossimRendererSubRectInfo::m_Vul

Definition at line 240 of file ossimImageRenderer.h.

Referenced by isViewEqual(), ossimRendererSubRectInfo(), and splitHorizontal().

◆ m_VulScale

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_VulScale

Definition at line 249 of file ossimImageRenderer.h.

◆ m_Vur

ossimIpt ossimImageRenderer::ossimRendererSubRectInfo::m_Vur

Definition at line 241 of file ossimImageRenderer.h.

Referenced by isViewEqual(), ossimRendererSubRectInfo(), and splitHorizontal().

◆ m_VurScale

ossimDpt ossimImageRenderer::ossimRendererSubRectInfo::m_VurScale

Definition at line 250 of file ossimImageRenderer.h.

The documentation for this class was generated from the following files:

Public Attributes
ossimDpt	m_Iul

ossimDpt	m_Iur

ossimDpt	m_Ilr

ossimDpt	m_Ill

ossimIpt	m_Vul

ossimIpt	m_Vur

ossimIpt	m_Vlr

ossimIpt	m_Vll

ossimDpt	m_ViewToImageScale

ossimDpt	m_ImageToViewScale

ossimDpt	m_VulScale

ossimDpt	m_VurScale

ossimDpt	m_VlrScale

ossimDpt	m_VllScale

ossimDpt	m_ulRoundTripError

ossimDpt	m_urRoundTripError

ossimDpt	m_lrRoundTripError

ossimDpt	m_llRoundTripError

ossimRefPtr< ossimImageViewTransform >	m_transform

const ossimPolyArea2d *	m_viewBounds

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Friends

Detailed Description

Member Enumeration Documentation

◆ SplitFlag

Constructor & Destructor Documentation

◆ ossimRendererSubRectInfo() [1/2]

◆ ossimRendererSubRectInfo() [2/2]

Member Function Documentation

◆ canBilinearInterpolate()

◆ computeRoundTripErrorViewPt()

◆ computeViewToImageScale()

◆ getAbsValueImageToViewScales()

◆ getAbsValueViewToImageScales()

◆ getImageMids()

◆ getImageRect()

◆ getParametricCenter()

◆ getSplitFlags()

◆ getViewMids()

◆ getViewRect()

◆ imageHasNans()

◆ imageIsNan()

◆ isIdentity()

◆ isViewAPoint()

◆ isViewEqual() [1/2]

◆ isViewEqual() [2/2]

◆ roundImageToInteger()

◆ roundToInteger()

◆ roundViewToInteger()

◆ splitAll()

◆ splitHorizontal()

◆ splitVertical()

◆ splitView()

◆ stretchImageOut()

◆ tooBig()

◆ transformImageToView()

◆ transformViewToImage()

◆ viewHasNans()

◆ viewIsNan()

Friends And Related Function Documentation

◆ operator<<

Member Data Documentation

◆ m_Ill

◆ m_Ilr

◆ m_ImageToViewScale

◆ m_Iul

◆ m_Iur

◆ m_llRoundTripError

◆ m_lrRoundTripError

◆ m_transform

◆ m_ulRoundTripError

◆ m_urRoundTripError

◆ m_viewBounds

◆ m_ViewToImageScale

◆ m_Vll

◆ m_VllScale

◆ m_Vlr

◆ m_VlrScale

◆ m_Vul

◆ m_VulScale

◆ m_Vur

◆ m_VurScale