Re-write of View::getResolution() to more robustly determine resolution level: handles images with levels either rounded up or down.

Update to IIIF.cc to more cleanly determine whether a request is for a tile or not and more accruately calculate normalized region sizes.

Author: ruven

ChangeLog

@@ -1,3 +1,10 @@
+31/12/2015:
+	- Re-write of View::getResolution() to more robustly determine resolution level: handles images with levels
+	  either rounded up or down.
+	- Update to IIIF.cc to more cleanly determine whether a request is for a tile or not and more accruately
+	  calculate normalized region sizes.
+
+
 28/12/2025:
 	- Eliminate warnings from GCC when using maximal compiler warning levels
 

src/IIIF.cc

@@ -373,7 +373,7 @@ void IIIF::run( Session* session, const string& src )
     int numOfTokens = 0;
 
     // Our region parameters (always between 0 and 1)
-    float region[4] = {0.0, 0.0, 1.0, 1.0};
+    double region[4] = {0.0, 0.0, 1.0, 1.0};
 
     // Region Parameter: { "full"; "square"; "x,y,w,h"; "pct:x,y,w,h" }
     if ( izer.hasMoreTokens() ){
@@ -420,8 +420,8 @@ void IIIF::run( Session* session, const string& src )
         }
 
         // Define our denominators as our session view expects a ratio, not pixel values
-        float wd = (float) width;
-        float hd = (float) height;
+        double wd = (double) width;
+        double hd = (double) height;
 
         if( isPCT ){
 	  wd = 100.0;
@@ -539,7 +539,7 @@ void IIIF::run( Session* session, const string& src )
           i.clear();
           i.str( sizeString.substr( pos + 1, string::npos ) );
           if ( !(i >> requested_height) ) throw invalid_argument( "invalid height" );
-        }
+	}
       }
 
 
@@ -738,15 +738,14 @@ void IIIF::run( Session* session, const string& src )
 
 
   // Determine whether this is a request for an individual tile which, therefore, coincides exactly with our tile boundaries
-  if( ( session->view->maintain_aspect && (requested_res > 0) &&
-	(view_left % tw == 0) && (view_top % th == 0) &&                            // Left / top boundaries align with tile positions
-	(requested_width == vtw) && (requested_height == vth) &&                    // Request is for exact tile dimensions
-	(session->view->getViewWidth() == vtw) && (session->view->getViewHeight() == vth) ) ||  // View size should also be identical to tile dimensions
-      // For smallest resolution, image size can be given as equal or less than tile size or exactly equal to tile size
-      ( ( session->view->maintain_aspect && (requested_res == 0) ) &&
-	( ( ((unsigned int) requested_width == im_width) && ((unsigned int) requested_height == im_height)) ||
-	  ( ((unsigned int) requested_width == tw) && ((unsigned int) requested_height == th)) ) )
-      ){
+  if(
+     // Left / top boundaries align with tile positions
+     (view_left % tw == 0) && (view_top % th == 0) &&
+     // Request is for exact tile dimensions (taking into account edge tile sizes)
+     (requested_width == vtw) && (requested_height == vth) &&
+     // View size should also be identical to tile dimensions
+     (session->view->getViewWidth() == vtw) && (session->view->getViewHeight() == vth)
+     ){
 
     // Get the width and height for last row and column tiles
     unsigned int rem_x = im_width % tw;

src/View.cc

@@ -23,45 +23,47 @@
 using namespace std;
 
 
-/// Calculate optimal resolution for a given requested pixel dimension
-void View::calculateResolution( const std::vector<unsigned int>& dimensions,
-				const unsigned int requested_size ){
-
-  int j;
-
-  // Make sure we have a minimum size
-  unsigned int rs = (requested_size<min_size) ? min_size : requested_size;
-
-  // Find the resolution level closest but higher than the requested size
-  for( j=0; j<(int)max_resolutions; j++ ){
-    if( dimensions[j] < rs ) break;
-  }
-
-  // Invert to convert to IIP resolutions (0=smallest) - note that we implicitly add 1 to get resolution higher than
-  j = max_resolutions-j;
-
-  // Limit j to the maximum resolution
-  if( j < 0 ) j = 0;
-  if( j > (int)(max_resolutions-1) ) j = max_resolutions - 1;
-
-  // Only update value of resolution if our calculated resolution is greater than value that has already been set
-  if( j > resolution ) resolution = j;
-}
-
 
 /// Calculate the optimal resolution and the size of this resolution for the requested view,
 /// taking into account any maximum size settings
 unsigned int View::getResolution( const std::vector<unsigned int>& widths, const std::vector<unsigned int>& heights ){
 
-  // Initialize our resolution to smallest available before calculating
-  resolution = 0;
+  int level;
 
+  // Get requested size - takes into account max size
   vector<unsigned int> requested_size = View::getRequestSize();
-  View::calculateResolution( widths, round((float)requested_size[0]/(float)view_width) );
-  View::calculateResolution( heights, round((float)requested_size[1]/(float)view_height) );
 
-  res_width = widths[max_resolutions-resolution-1];
-  res_height = heights[max_resolutions-resolution-1];
+  // Start from the smallest resolution size (last item in size array)
+  for( level = (int) max_resolutions - 1; level >= 0; level-- ){
+
+    // Scaling factor (assume powers of 2)
+    unsigned int factor = 1 << level;
+
+    // For some reason, this needs to be done in 2 steps with fw, fh first, otherwise rounding errors occur :-/
+    float fw = (float) width * view_width;
+    // For full width or height requests use the real level size.
+    // Also add an epsilon to avoid floating-point rounding errors when using floor()
+    unsigned int scaled_width = (view_width == 1.0) ? widths[level] : floor( (fw/factor) + numeric_limits<float>::epsilon() );
+    float fh = (float) height * view_height;
+    unsigned int scaled_height = (view_height == 1.0) ? heights[level] : floor( (fh/factor) + numeric_limits<float>::epsilon() );
+
+    // Note that we add 1px for the first checks to take into account differences between levels that have rounded up or down
+    if( scaled_width <= (widths[level]+1) && scaled_height <= (heights[level]+1) &&
+	// Skip check and avoid potential rounding errors if only a single dimension has been requested
+	( requested_width == 0 ? true : scaled_width >= requested_size[0] ) &&
+        ( requested_height == 0 ? true : scaled_height >= requested_size[1] ) ){
+      break; // Lowest resolution where conditions are met
+    }
+  }
+  // Clamp to 0 if no matches
+  if( level < 0 ) level = 0;
+
+  // Size of image at this level
+  res_width = widths[level];
+  res_height = heights[level];
+
+  // Store resolution as IIP resolution (0=smallest)
+  resolution = max_resolutions - level - 1;
 
   // Check if we need to limit to a smaller resolution due to our max size limit
   float scale = getScale();
@@ -119,29 +121,29 @@ float View::getScale(){
 }
 
 
-void View::setViewLeft( float x ) {
+void View::setViewLeft( double x ) {
   if( x > 1.0 ) view_left = 1.0;
   else if( x < 0.0 ) view_left = 0.0;
   else view_left = x;
 }
 
 
-void View::setViewTop( float y ) {
+void View::setViewTop( double y ) {
   if( y > 1.0 ) view_top = 1.0;
   else if( y < 0.0 ) view_top = 0.0;
   else view_top = y;
 }
 
 
-void View::setViewWidth( float w ) {
+void View::setViewWidth( double w ) {
   // Sanity check
   if( w > 1.0 ) view_width = 1.0;
   else if( w < 0.0 ) view_width = 0.0;
   else view_width = w;
 }
 
 
-void View::setViewHeight( float h ) {
+void View::setViewHeight( double h ) {
   // Sanity check
   if( h > 1.0 ) view_height = 1.0;
   else if( h < 0.0 ) view_height = 0.0;

src/View.h

@@ -39,7 +39,7 @@ class View{
  private:
 
   // Resolution independent x,y,w,h region viewport in range 0 -> 1.0
-  float view_left, view_top, view_width, view_height; /// viewport
+  double view_left, view_top, view_width, view_height; /// viewport
 
   int resolution;                             ///< Requested resolution where 0 is smallest available
   unsigned int max_resolutions;               ///< Total available resolutions
@@ -190,28 +190,28 @@ class View{
 
   /// Set the left co-ordinate of the viewport
   /** @param x left resolution independent co-ordinate */
-  void setViewLeft( float x );
+  void setViewLeft( double x );
 
 
   /// Set the top co-ordinate of the viewport
   /** @param y top resolution independent co-ordinate */
-  void setViewTop( float y );
+  void setViewTop( double y );
 
 
   /// Set the width co-ordinate of the viewport
   /** @param w width resolution independent co-ordinate */
-  void setViewWidth( float w );
+  void setViewWidth( double w );
 
 
   /// Set the height co-ordinate of the viewport
   /** @param h height resolution independent co-ordinate */
-  void setViewHeight( float h );
+  void setViewHeight( double h );
 
 
   /// Return the view dimensions scaled to the full resolution of the image
   /** @return size view dimensions on the full resolution canvas packed into a vector */
   std::vector<float> getViewSize(){
-    std::vector<float> size = { width*view_width, height*view_height };
+    std::vector<float> size = { width*(float)view_width, height*(float)view_height };
     return size;
   };