OSSIM - Open Source Software Image Map: ossimImageViewProjectionTransform Class Reference

T * get()

Definition: ossimRefPtr.h:83

ossimRefPtr< ossimImageGeometry > m_imageGeometry

Definition: ossimImageViewProjectionTransform.h:123

◆ getImageGeometry() [2/2]

const ossimImageGeometry* ossimImageViewProjectionTransform::getImageGeometry ( ) const

inline

Definition at line 61 of file ossimImageViewProjectionTransform.h.

61 { return m_imageGeometry.get(); }

T * get()

Definition: ossimRefPtr.h:83

References ossimGpt::datum(), ossimProjection::getGroundClipPoints(), ossimImageViewTransform::getImageToViewBounds(), ossimImageGeometry::getProjection(), ossimGeoPolygon::getVertexList(), ossimDrect::hasNans(), ossimImageGeometry::hasProjection(), ossimDrect::ll(), ossimImageGeometry::localToWorld(), ossimDrect::lr(), m_imageGeometry, m_viewGeometry, ossimProjection::origin(), ossimGeoPolygon::size(), ossimDrect::ul(), ossimDrect::ur(), ossimRefPtr< T >::valid(), and ossimImageGeometry::worldToLocal().

ossimRefPtr< ossimImageGeometry > m_imageGeometry

Definition: ossimImageViewProjectionTransform.h:123

◆ getImageToViewBounds()

ossimDrect ossimImageViewProjectionTransform::getImageToViewBounds ( const ossimDrect & imageRect ) const

virtual

Gets the image bounding rect in view-space coordinates.

Reimplemented from ossimImageViewTransform.

Definition at line 417 of file ossimImageViewProjectionTransform.cpp.

Referenced by initializeViewSize().

 {
     // 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;
 }

◆ getInputMetersPerPixel()

ossimDpt ossimImageViewProjectionTransform::getInputMetersPerPixel ( ) const

virtual

Returns the GSD of input image.

Implements ossimImageViewTransform.

Definition at line 515 of file ossimImageViewProjectionTransform.cpp.

References ossimProjection::getMetersPerPixel(), ossimImageGeometry::getProjection(), ossimImageGeometry::hasProjection(), m_imageGeometry, ossimDpt::makeNan(), and ossimRefPtr< T >::valid().

 {
     ossimDpt result;
 
     if (m_imageGeometry.valid() && m_imageGeometry->hasProjection())
         result = m_imageGeometry->getProjection()->getMetersPerPixel();
     else
         result.makeNan();
 
     return result;
 }

◆ getOutputMetersPerPixel()

ossimDpt ossimImageViewProjectionTransform::getOutputMetersPerPixel ( ) const

virtual

Returns the GSD of the output view.

Implements ossimImageViewTransform.

Definition at line 530 of file ossimImageViewProjectionTransform.cpp.

References ossimProjection::getMetersPerPixel(), ossimImageGeometry::getProjection(), ossimImageGeometry::hasProjection(), m_viewGeometry, ossimDpt::makeNan(), and ossimRefPtr< T >::valid().

 {
     ossimDpt result;
 
     if(m_viewGeometry.valid() && m_viewGeometry->hasProjection())
         result = m_viewGeometry->getProjection()->getMetersPerPixel();
     else
         result.makeNan();
 
     return result;
 }

◆ getView() [1/2]

virtual ossimObject* ossimImageViewProjectionTransform::getView ( )

inlinevirtual

Implements ossimViewInterface.

Definition at line 90 of file ossimImageViewProjectionTransform.h.

90 { return m_viewGeometry.get(); }

T * get()

Definition: ossimRefPtr.h:83

ossimRefPtr< ossimImageGeometry > m_viewGeometry

Definition: ossimImageViewProjectionTransform.h:124

◆ getView() [2/2]

virtual const ossimObject* ossimImageViewProjectionTransform::getView ( ) const

inlinevirtual

Implements ossimViewInterface.

Definition at line 91 of file ossimImageViewProjectionTransform.h.

91 { return m_viewGeometry.get(); }

T * get()

Definition: ossimRefPtr.h:83

ossimRefPtr< ossimImageGeometry > m_viewGeometry

Definition: ossimImageViewProjectionTransform.h:124

◆ getViewGeometry() [1/2]

ossimImageGeometry* ossimImageViewProjectionTransform::getViewGeometry ( )

inline

Definition at line 60 of file ossimImageViewProjectionTransform.h.

Referenced by ossimImageRenderer::getImageGeometry(), and ossimImageRenderer::initializeBoundingRects().

60 { return m_viewGeometry.get(); }

T * get()

Definition: ossimRefPtr.h:83

ossimRefPtr< ossimImageGeometry > m_viewGeometry

Definition: ossimImageViewProjectionTransform.h:124

◆ getViewGeometry() [2/2]

const ossimImageGeometry* ossimImageViewProjectionTransform::getViewGeometry ( ) const

inline

Definition at line 62 of file ossimImageViewProjectionTransform.h.

62 { return m_viewGeometry.get(); }

T * get()

Definition: ossimRefPtr.h:83

ossimRefPtr< ossimImageGeometry > m_viewGeometry

Definition: ossimImageViewProjectionTransform.h:124

◆ getViewSegments()

void ossimImageViewProjectionTransform::getViewSegments	(	std::vector< ossimDrect > &	viewBounds,
		ossimPolyArea2d &	polyArea,
		ossim_uint32	numberOfEdgePoints = `25`
	)		const

virtual

Because of the fact we can have dateline crossings there exist on the view plane both positive and negative bounds.

We need a generalized interface that allows us to calculate the valid bounds of an image transformed to the view.

Parameters

viewBounds	Returns bounds for each segment
polyArea	Returns the polygons for each segment.
numberOfEdgePoints	If the value is 0 it will do a standard bounds check. If the paramter is greater than 0 this will only be used if the input projection is affected by elevation. If it's not affected by elevation then the default bounds will be calculated.

Definition at line 189 of file ossimImageViewProjectionTransform.cpp.

References ossimPolyArea2d::add(), ossimPolyArea2d::clear(), ossimPolygon::clear(), ossimPolygon::clipToRect(), ossimImageGeometry::getBoundingRect(), ossimImageGeometry::getImageEdgePoints(), ossimDpt::hasNans(), imageToView(), ossimImageGeometry::isAffectedByElevation(), ossimGpt::isLatNan(), ossimGpt::isLonNan(), ossimDrect::ll(), ossimImageGeometry::localToWorld(), ossimGpt::lond(), ossimDrect::lr(), m_crossesDateline, m_imageGeometry, m_viewGeometry, ossimDrect::midPoint(), ossim::sgn(), ossimDrect::ul(), ossimDrect::ur(), ossimRefPtr< T >::valid(), and ossimImageGeometry::worldToLocal().

Referenced by ossimImageRenderer::initializeBoundingRects().

 {
   ossimDrect imageRect;
   ossimDrect worldRect(ossimDpt(-180,-90),
                        ossimDpt(-180,90),
                        ossimDpt(180,90),
                        ossimDpt(180,-90));
   viewBounds.clear();
   polyArea.clear();
 
   if(m_imageGeometry.valid())
   {
     m_imageGeometry->getBoundingRect(imageRect);
     ossim_uint32 idx=0;
     std::vector<ossimDpt> points;
     std::vector<ossimGpt> gPoints;
     bool affectedByElevation = m_imageGeometry->isAffectedByElevation();
 
 
     if((numberOfEdgePoints > 2)&&(affectedByElevation))
     {
       m_imageGeometry->getImageEdgePoints(points, numberOfEdgePoints);
     }
     else
     {
       points.resize(4);
 
       points[0] = imageRect.ul();
       points[1] = imageRect.ur();
       points[2] = imageRect.lr();
       points[3] = imageRect.ll();
     }
     if(m_crossesDateline)
     {
       ossimDpt testPt;
       ossimGpt cg;
       m_imageGeometry->localToWorld(imageRect.midPoint(), cg);
       ossim_int32 sgn = static_cast<ossim_int32>(ossim::sgn(cg.lond()));
       std::vector<ossimPolygon> polyList;
       for(idx=0; idx < points.size();++idx)
       {
         ossimGpt testGpt;
         m_imageGeometry->localToWorld(points[idx], testGpt); 
 
         if(!testGpt.isLatNan()&&!testGpt.isLonNan())
         {
           gPoints.push_back(testGpt);        
         }
       }
 
       // first we get the list of ground points initialized
       // and shifted to one side of the full world rect
       // We will do the other side next
       //
       for(idx=0; idx < gPoints.size();++idx)
       {
          if(std::fabs(gPoints[idx].lond()-cg.lond()) > 180)
          {
             gPoints[idx].lond(gPoints[idx].lond()+sgn*360);
          }
       }
 
       // now clip the ground list to the full ground rect
       //
       ossimPolygon tempPoly(gPoints);
       tempPoly.clipToRect(polyList, worldRect);
 
       ossim_uint32 pointListIdx=0;
 
       // Loop through the clipped polygons and find their 
       // view projection.  We will add this to the view
       // bounds and we will add to the poly Area.  Poly Area
       // is used for a tighter clip.
       //
       for(pointListIdx=0;pointListIdx<polyList.size();++pointListIdx)
       {
          const std::vector<ossimDpt>& clipPoints = polyList[pointListIdx].getVertexList();
          points.clear();
          for(idx = 0; idx<clipPoints.size(); ++idx)
          {
             m_viewGeometry->worldToLocal(ossimGpt(clipPoints[idx]), testPt);
             if(!testPt.hasNans())
             {
                points.push_back(testPt);
             }
          }
          viewBounds.push_back(ossimDrect(points));
 
          if (points.size() >= 4)
          {
             points.push_back(points[0]);
             polyArea.add(ossimPolyArea2d(points));//ossimPolygon(points)));
          }
       }
 
       // now shift the ground points to the other side of the world rect
       //
       for(idx=0; idx < gPoints.size();++idx)
       {
         gPoints[idx].lond(gPoints[idx].lond()+(-sgn*360));
       }
 
       // Now we will do the same thing to the other side of the world
       // and find the view projection and add those to the poly area
       // and the view rect
       //
       tempPoly = gPoints;
       polyList.clear();
       tempPoly.clipToRect(polyList, worldRect);
 
       for(pointListIdx=0;pointListIdx<polyList.size();++pointListIdx)
       {
          const std::vector<ossimDpt>& clipPoints = polyList[pointListIdx].getVertexList();
          points.clear();
          for(idx = 0; idx<clipPoints.size(); ++idx)
          {
             m_viewGeometry->worldToLocal(ossimGpt(clipPoints[idx]), testPt);
             if(!testPt.hasNans())
             {
                points.push_back(testPt);
             }
          }
          viewBounds.push_back(ossimDrect(points));
          if (points.size() >= 4)
          {
             points.push_back(points[0]);
             polyArea.add(ossimPolyArea2d(points));//ossimPolygon(points)));
          }
 
       }
     }// end: if(m_crossesDateline)
     else 
     {
       ossimDpt testPoint;
       std::vector<ossimDpt> vpoints;
 
       for(idx=0; idx < points.size();++idx)
       {
         ossimDpt testDpt;
         imageToView(points[idx], testDpt); 
         if(!testDpt.hasNans())
         {
           vpoints.push_back(testDpt);
         }
       }
   
       if(vpoints.size())
       {
         vpoints.push_back(vpoints[0]);
         viewBounds.push_back(ossimDrect(vpoints));
         polyArea = vpoints;// = ossimPolyArea2d(points);
 
       }
     }
   } 
 }

◆ imageToView()

void ossimImageViewProjectionTransform::imageToView	(	const ossimDpt &	imagePoint,
		ossimDpt &	viewPoint
	)		const

virtual

Workhorse of the object. Converts image-space to view-space.

Reimplemented from ossimImageViewTransform.

Definition at line 81 of file ossimImageViewProjectionTransform.cpp.

References ossimImageGeometry::decimationFactor(), ossimImageGeometry::fullToRn(), ossimImageGeometry::getProjection(), ossimImageGeometry::getTransform(), ossimImageGeometry::localToWorld(), m_imageGeometry, m_viewGeometry, ossimDpt::makeNan(), ossimImageGeometry::rnToFull(), and ossimImageGeometry::worldToLocal().

Referenced by ATP::AtpGenerator::constructChain(), ATP::AtpGenerator::getValidVertices(), and getViewSegments().

 {
    // Check for same geometries on input and output (this includes NULL geoms):
    if (m_imageGeometry == m_viewGeometry)
    {
       vp = ip;
       return;
    }
    
    // Otherwise we need access to good geoms. Check for a bad geometry object:
    if (!m_imageGeometry || !m_viewGeometry)
    {
       vp.makeNan();
       return;
    }
    
    // Check for same projection on input and output sides to save projection to ground:
    if (m_imageGeometry->getProjection() == m_viewGeometry->getProjection())
    {
       // Check for possible same 2D transforms as well:
       if ( (m_imageGeometry->getTransform() == m_viewGeometry->getTransform()) &&
            (m_imageGeometry->decimationFactor(0) == m_viewGeometry->decimationFactor(0)) )
       {
          vp = ip;
          return;
       }
       
       // Not the same 2D transform, so just perform local-image -> full-image -> local-view:
       ossimDpt fp;
       m_imageGeometry->rnToFull(ip, 0, fp);
       m_viewGeometry->fullToRn(fp, 0, vp);
       return;
    }
    
    //---
    // Completely different left and right side geoms (typical situation).
    // Need to project to ground.
    //---
    ossimGpt gp;
    m_imageGeometry->localToWorld(ip, gp);
    m_viewGeometry->worldToLocal(gp, vp);
 
 #if 0 /* Please leave for debug. */
    cout <<"DEBUG ossimImageViewProjectionTransform::imageToView:"
         <<"\n    ip: "<<ip
         <<"\n    gp: "<<gp
         <<"\n    vp: "<<vp<<std::endl;
 #endif
 }

◆ initializeDatelineCrossing()

void ossimImageViewProjectionTransform::initializeDatelineCrossing ( )

protected

Definition at line 741 of file ossimImageViewProjectionTransform.cpp.

References ossimImageGeometry::getCrossesDateline(), m_crossesDateline, m_imageGeometry, and ossimRefPtr< T >::valid().

Referenced by setImageGeometry(), and setViewGeometry().

 {
   m_crossesDateline = false;
   if(m_imageGeometry.valid())
   {
     m_crossesDateline = m_imageGeometry->getCrossesDateline();
   }
 }

◆ initializeViewSize()

bool ossimImageViewProjectionTransform::initializeViewSize ( )

protected

Initializes the view geometry image size from image geometry bounding rect.

This is needed for the ossimImageGeometry::worldToLocal if the underlying projection is geographic to handle images that cross the date line.

Parameters

Input image rectangle.

Returns: true on success, false on error.

Definition at line 543 of file ossimImageViewProjectionTransform.cpp.

References ossimRefPtr< T >::get(), ossimImageGeometry::getCrossesDateline(), ossimMapProjection::getDecimalDegreesPerPixel(), ossimImageGeometry::getImageSize(), getImageToViewBounds(), ossimImageGeometry::getProjection(), ossimDrect::height(), ossimGpt::lat, ossimImageGeometry::localToWorld(), ossimGpt::lon, ossimGpt::lond(), m_crossesDateline, m_imageGeometry, m_viewGeometry, ossimImageGeometry::setImageSize(), ossim::sgn(), size, ossimRefPtr< T >::valid(), ossimDrect::width(), ossimImageGeometry::worldToLocal(), ossimIpt::x, ossimDpt::x, ossimIpt::y, and ossimDpt::y.

Referenced by setView().

 {
    bool result = false;
    m_crossesDateline = false;
    if ( m_imageGeometry.valid() )
    {
       m_crossesDateline = m_imageGeometry->getCrossesDateline();
       ossimDrect imageRect( 0, 0,
                             m_imageGeometry->getImageSize().x - 1,
                             m_imageGeometry->getImageSize().y - 1);
       ossimDpt size;
       ossimDrect rect;
       if(m_crossesDateline)
       {
          ossimGpt ulg;
          ossimGpt urg;
          ossimGpt lrg;
          ossimGpt llg;
          ossimGpt cg;
          ossimDpt ul;
          ossimDpt ur;
          ossimDpt lr;
          ossimDpt ll;
          m_imageGeometry->localToWorld(imageRect.ul(), ulg);
          m_imageGeometry->localToWorld(imageRect.ur(), urg);
          m_imageGeometry->localToWorld(imageRect.lr(), lrg);
          m_imageGeometry->localToWorld(imageRect.ll(), llg);
          m_imageGeometry->localToWorld(imageRect.midPoint(), cg);
 
          if(std::fabs(ulg.lond()-cg.lond()) > 180)
          {
             ulg.lond(ulg.lond()+ossim::sgn(cg.lond())*360);
          }
          if(std::fabs(urg.lond()-cg.lond()) > 180)
          {
             urg.lond((urg.lond()+ossim::sgn(cg.lond())*360));
          }
          if(std::fabs(lrg.lond()-cg.lond()) > 180)
          {
             lrg.lond(lrg.lond()+ossim::sgn(cg.lond())*360);
          }
          if(std::fabs(llg.lond()-cg.lond()) > 180)
          {
             llg.lond(llg.lond()+ossim::sgn(cg.lond())*360);
          }
 
          m_viewGeometry->worldToLocal(ulg, ul);
          m_viewGeometry->worldToLocal(urg, ur);
          m_viewGeometry->worldToLocal(lrg, lr);
          m_viewGeometry->worldToLocal(llg, ll);
 
          rect= ossimDrect(ul,ur,lr,ll);
       }
       else
       {
         rect = getImageToViewBounds( imageRect );
       }
       size.x = ossim::round<ossim_int32>( rect.width()  );
       size.y = ossim::round<ossim_int32>( rect.height() );
       if ( size.hasNans() == false )
       {
          m_viewGeometry->setImageSize( size );
          result = true;
       }
 //      std::cout << "VIEW SIZE ============== " << size << "\n";
 #if 0
 
       if ( (imageRect.hasNans() == false) && m_viewGeometry.valid() )
       {
          ossimRefPtr<ossimProjection> viewProj = m_viewGeometry->getProjection();
          if ( viewProj.valid() )
          {
             ossimIpt size;
             size.makeNan();
             
             const ossimEquDistCylProjection* eqProj =
                dynamic_cast<const ossimEquDistCylProjection*>( viewProj.get() );
             if ( eqProj )
             {
                // Specialized to take into consideration a date line crossing.
                
                // Get the ground points we need:
                ossimDpt iRight(imageRect.ul().x+1, imageRect.ul().y);
                ossimDpt iDown(imageRect.ul().x, imageRect.ul().y+1);
                ossimGpt gul;
                ossimGpt gur; 
                ossimGpt glr;
                ossimGpt gll;
                ossimGpt gRight;
                ossimGpt gDown;
                ossim_float64 hdd; // height decimal degrees
                ossim_float64 wdd; // width decimal degrees
                ossim_float64 leftLon;
                ossim_float64 rightLon;
                
                m_imageGeometry->localToWorld( imageRect.ul(), gul );
                m_imageGeometry->localToWorld( imageRect.ur(), gur );
                m_imageGeometry->localToWorld( imageRect.lr(), glr );
                m_imageGeometry->localToWorld( imageRect.ll(), gll );
                m_imageGeometry->localToWorld( iRight, gRight );
                m_imageGeometry->localToWorld( iDown, gDown );
                
                //---
                // Determine the direction of the image and get the geographic bounding box.
                // For the longitude consider a date line crossing.
                //---
                if ( gul.lat > gDown.lat ) // oriented north up
                {
                   if ( gul.lat >= gRight.lat ) // straight up or leaning right
                   {
                      hdd      = gul.lat - glr.lat;
                      leftLon  = gll.lon;
                      rightLon = gur.lon;
                   }
                   else // leaning left
                   {
                      hdd      = gur.lat - gll.lat;
                      leftLon  = gul.lon;
                      rightLon = glr.lon;
                   }
                }
                else // south or on side
                {
                   if ( gRight.lat >= gul.lat ) // straight down or leaning right
                   {
                      hdd      = glr.lat - gul.lat;
                      leftLon  = gur.lon;
                      rightLon = gll.lon;
                   }
                   else // leaning left
                   {
                      hdd      = gll.lat - gur.lat;
                      leftLon  = glr.lon;
                      rightLon = gul.lon;
                   }
                }
                
                if ( rightLon > leftLon )
                {
                   wdd = rightLon - leftLon;
                }
                else // Date line cross:
                {
                   wdd = rightLon + 360.0 - leftLon;
                }
 
                //---
                // Add one pixel width/height to the point to point size to make it edge to edge
                // before dividing by gsd to get the size.  The view projection gsd is used here
                // since the view could be a different resolution than the input projection.
                //---
                size.x = ossim::round<ossim_int32>(
                   ( wdd + eqProj->getDecimalDegreesPerPixel().x ) /
                   eqProj->getDecimalDegreesPerPixel().x );
                size.y = ossim::round<ossim_int32>(
                   ( hdd + eqProj->getDecimalDegreesPerPixel().y ) /
                   eqProj->getDecimalDegreesPerPixel().y );
                
 #if 0 /* Please leave for debug: */
                cout << "\nwdd: " << wdd
                     << "\nhdd: " << hdd
                     << "\ngul: " << gul
                     << "\ngur: " << gur
                     << "\nglr: " << glr
                     << "\ngll: " << gll
                     << endl;
 #endif
             }
             else // Not an ossimEquDistCylProjection:
             {
                ossimDrect rect = getImageToViewBounds( imageRect );
                size.x = ossim::round<ossim_int32>( rect.width()  );
                size.y = ossim::round<ossim_int32>( rect.height() );
             }
 
 #if 0 /* Please leave for debug: */
             cout << "m_imageGeometry:\n" << *(m_imageGeometry.get())
                  << "\n\nm_viewGeometry:\n" << *(m_viewGeometry.get())
                  << "\n\ncomputed view size: " << size << endl;
 #endif
             
             if ( size.hasNans() == false )
             {
                m_viewGeometry->setImageSize( size );
                result = true;
             }
             
          } // Matches: if ( viewProj.valid() )
 
       } // Matches: if ( (imageRect.hasNans() == false) ... 
 #endif
       
    } // Matches: if ( m_imageGeometry.valid() && ...
 
    return result;
    
 } // End:  bool ossimImageViewProjectionTransform::initializeViewSize()

◆ isIdentity()

virtual bool ossimImageViewProjectionTransform::isIdentity ( ) const

inlinevirtual

Returns TRUE if both input and output geometries are identical.

Presently implemented as limited compare of geometry pointers

Implements ossimImageViewTransform.

Definition at line 42 of file ossimImageViewProjectionTransform.h.

42 { return (m_imageGeometry == m_viewGeometry); }

ossimRefPtr< ossimImageGeometry > m_imageGeometry

Definition: ossimImageViewProjectionTransform.h:123

ossimRefPtr< ossimImageGeometry > m_viewGeometry

Definition: ossimImageViewProjectionTransform.h:124

◆ isValid()

virtual bool ossimImageViewProjectionTransform::isValid ( void ) const

inlinevirtual

Satisfies base class pure virtual. Returns TRUE if both input and output geoms exist.

Implements ossimImageViewTransform.

Definition at line 38 of file ossimImageViewProjectionTransform.h.

38 { return (m_imageGeometry.valid() && m_viewGeometry.valid()); }

ossimRefPtr::valid

bool valid() const

Definition: ossimRefPtr.h:75

ossimRefPtr< ossimImageGeometry > m_imageGeometry

Definition: ossimImageViewProjectionTransform.h:123