Thread: [Hugin-cvs] SF.net SVN: hugin: [2618] hugin/trunk (Page 2)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Revision: 2618
          http://hugin.svn.sourceforge.net/hugin/?rev=2618&view=rev
Author:   dangelo
Date:     2008-01-11 00:38:22 -0800 (Fri, 11 Jan 2008)

Log Message:
-----------
Added support for using exif2 (patch by Gerry Patterson)

Modified Paths:
--------------
    hugin/trunk/CMakeLists.txt
    hugin/trunk/src/CMakeLists.txt
    hugin/trunk/src/hugin_base/panodata/SrcPanoImage.cpp
    hugin/trunk/src/hugin_base/panodata/SrcPanoImage.h
    hugin/trunk/src/hugin_config.h.in.cmake

Added Paths:
-----------
    hugin/trunk/CMakeModules/FindExiv2.cmake

Modified: hugin/trunk/CMakeLists.txt
===================================================================

--- hugin/trunk/CMakeLists.txt	2008-01-09 16:38:07 UTC (rev 2617)
+++ hugin/trunk/CMakeLists.txt	2008-01-11 08:38:22 UTC (rev 2618)
@@ -98,9 +98,18 @@
 INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
 INCLUDE_DIRECTORIES(${PNG_INCLUDE_DIR})
 
+
 FIND_PACKAGE(OpenEXR REQUIRED)
 include_directories(${OPENEXR_INCLUDE_DIR})
 
+FIND_PACKAGE(Exiv2)
+IF(EXIV2_FOUND)
+    IF (HUGIN_USE_EXIV2)
+        ADD_DEFINITIONS (-DHUGIN_USE_EXIV2)
+        INCLUDE_DIRECTORIES(${EXIV2_INCLUDE_DIR})
+    ENDIF (HUGIN_USE_EXIV2)
+ENDIF(EXIV2_FOUND)
+
 ##
 ## Panotools
 ##

Added: hugin/trunk/CMakeModules/FindExiv2.cmake
===================================================================
--- hugin/trunk/CMakeModules/FindExiv2.cmake	                        (rev 0)
+++ hugin/trunk/CMakeModules/FindExiv2.cmake	2008-01-11 08:38:22 UTC (rev 2618)
@@ -0,0 +1,77 @@
+# - Try to find the Exiv2 library
+# Once done this will define
+#
+#  EXIV2_FOUND - system has libexiv2
+#  EXIV2_INCLUDE_DIR - the libexiv2 include directory
+#  EXIV2_LIBRARIES - Link these to use libexiv2
+#  EXIV2_DEFINITIONS - Compiler switches required for using libexiv2
+#
+
+if (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
+
+  # in cache already
+  SET(EXIV2_FOUND TRUE)
+
+else (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
+  if (NOT WIN32)
+  # use pkg-config to get the directories and then use these values
+  # in the FIND_PATH() and FIND_LIBRARY() calls
+  INCLUDE(UsePkgConfig)
+  
+  PKGCONFIG(exiv2 _EXIV2IncDir _EXIV2LinkDir _EXIV2LinkFlags _EXIV2Cflags)
+
+  if(_EXIV2LinkFlags)
+    # query pkg-config asking for a Exiv2 >= 0.12
+    EXEC_PROGRAM(${PKGCONFIG_EXECUTABLE} ARGS --atleast-version=0.12 exiv2 RETURN_VALUE _return_VALUE OUTPUT_VARIABLE _pkgconfigDevNull )
+    if(_return_VALUE STREQUAL "0")
+      message(STATUS "Found Exiv2 release >= 0.12")
+      set(EXIV2_VERSION_GOOD_FOUND TRUE)
+    else(_return_VALUE STREQUAL "0")
+      message(STATUS "Found Exiv2 release < 0.12")
+    endif(_return_VALUE STREQUAL "0")
+  else(_EXIV2LinkFlags)
+      set(EXIV2_FOUND FALSE)
+      set(EXIV2_VERSION_GOOD_FOUND FALSE)
+      message(STATUS "Cannot find Exiv2 library!")
+  endif(_EXIV2LinkFlags)
+  
+  else(NOT WIN32)
+     #Better check
+     set(EXIV2_VERSION_GOOD_FOUND TRUE)
+  endif (NOT WIN32)
+
+  if(EXIV2_VERSION_GOOD_FOUND)
+     set(EXIV2_DEFINITIONS ${_EXIV2Cflags})
+ 
+     FIND_PATH(EXIV2_INCLUDE_DIR exiv2/exif.hpp
+       ${_EXIV2IncDir}
+     )
+  
+     FIND_LIBRARY(EXIV2_LIBRARIES NAMES exiv2 libexiv2
+       PATHS
+       ${_EXIV2LinkDir}
+     )
+  
+     if (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
+        set(EXIV2_FOUND TRUE)
+     endif (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
+   endif(EXIV2_VERSION_GOOD_FOUND)
+   if (EXIV2_FOUND)
+      if (NOT Exiv2_FIND_QUIETLY)
+       message(STATUS "Found Exiv2: ${EXIV2_LIBRARIES}")
+      endif (NOT Exiv2_FIND_QUIETLY)
+   else (EXIV2_FOUND)
+     if (Exiv2_FIND_REQUIRED)
+       if (NOT EXIV2_INCLUDE_DIR)
+         message(FATAL_ERROR "Could NOT find Exiv2 header files")
+       endif (NOT EXIV2_INCLUDE_DIR)
+       if (NOT EXIV2_LIBRARIES)
+           message(FATAL_ERROR "Could NOT find Exiv2 library")
+       endif (NOT EXIV2_LIBRARIES)
+     endif (Exiv2_FIND_REQUIRED)
+   endif (EXIV2_FOUND)
+
+  MARK_AS_ADVANCED(EXIV2_INCLUDE_DIR EXIV2_LIBRARIES)
+  
+endif (EXIV2_INCLUDE_DIR AND EXIV2_LIBRARIES)
+

Modified: hugin/trunk/src/CMakeLists.txt
===================================================================
--- hugin/trunk/src/CMakeLists.txt	2008-01-09 16:38:07 UTC (rev 2617)
+++ hugin/trunk/src/CMakeLists.txt	2008-01-11 08:38:22 UTC (rev 2618)
@@ -18,7 +18,7 @@
 ENDIF (MSVC)
 
 set(image_libs huginvigraimpex ${OPENEXR_LIBRARIES} ${JPEG_LIBRARIES} ${TIFF_LIBRARIES}
-    ${PNG_LIBRARIES} ${ZLIB_LIBRARIES})
+    ${PNG_LIBRARIES} ${ZLIB_LIBRARIES} ${EXIV2_LIBRARIES})
 
 add_subdirectory(foreign)
 add_subdirectory(hugin_base)

Modified: hugin/trunk/src/hugin_base/panodata/SrcPanoImage.cpp
===================================================================
--- hugin/trunk/src/hugin_base/panodata/SrcPanoImage.cpp	2008-01-09 16:38:07 UTC (rev 2617)
+++ hugin/trunk/src/hugin_base/panodata/SrcPanoImage.cpp	2008-01-11 08:38:22 UTC (rev 2618)
@@ -35,6 +35,11 @@
 #include <hugin_utils/utils.h>
 #include <jhead/jhead.h>
 
+#ifdef HUGIN_USE_EXIV2
+#include <exiv2/exif.hpp>
+#include <exiv2/image.hpp>
+#endif
+
 namespace HuginBase {
 
 using namespace hugin_utils;
@@ -309,8 +314,6 @@
 }
 
 
-
-
 bool SrcPanoImage::initImageFromFile(SrcPanoImage & img, double & focalLength, double & cropFactor)
 {
     std::string filename = img.getFilename();
@@ -327,8 +330,218 @@
     } catch(vigra::PreconditionViolation & ) {
         return false;
     }
+
+    // Setup image with default values
     img.setSize(vigra::Size2D(width, height));
+    img.setExifFocalLength(focalLength);
+    img.setExifCropFactor(cropFactor);
+    img.setRoll(roll);
+    if (focalLength > 0 && cropFactor > 0) {
+        img.setHFOV(calcHFOV(img.getProjection(), 
+                    focalLength, cropFactor, img.getSize()));
+    }
+
+#ifdef HUGIN_USE_EXIV2 
+    Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(filename.c_str());
+    if (image.get() == 0) {
+        std::cout << "Unable to open file to read EXIF data: " << filename << std::endl;
+        return false;
+    }
+
+    image->readMetadata();
+    Exiv2::ExifData &exifData = image->exifData();
+    if (exifData.empty()) {
+        std::cout << "Unable to read EXIF data from opened file:" << filename << std::endl;
+        return false;
+    }
+
+    float exposureTime = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.ExposureTime",exposureTime);
+
+    float photoFNumber = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.FNumber",photoFNumber);
+
+    if (exposureTime > 0 && photoFNumber > 0) {
+        double gain = 1;
+        float isoSpeed = 0;
+        if (img.getExiv2Value(exifData,"Exif.Photo.ISOSpeedRatings",isoSpeed)) {
+            if (isoSpeed > 0) {
+                gain = isoSpeed / 100.0;
+            }
+        }
+        float eV = log2(photoFNumber * photoFNumber / (gain * exposureTime));
+        DEBUG_DEBUG ("Ev: " << eV);
+        img.setExposureValue(eV);
+    }
     
+    Exiv2::ExifKey key("Exif.Image.Make");
+    Exiv2::ExifData::iterator itr = exifData.findKey(key);
+    if (itr != exifData.end())
+        img.setExifMake(itr->toString());
+    else
+        img.setExifMake("Unknown");
+
+    Exiv2::ExifKey key2("Exif.Image.Model");
+    itr = exifData.findKey(key2);
+    if (itr != exifData.end())
+        img.setExifModel(itr->toString());
+    else
+        img.setExifModel("Unknown");
+
+    long orientation = 0;
+    if (img.getExiv2Value(exifData,"Exif.Image.Orientation",orientation)) {
+        switch (orientation) {
+            case 3:  // rotate 180
+                roll = 180;
+                break;
+            case 6: // rotate 90
+                roll = 90;
+                break;
+            case 8: // rotate 270
+                roll = 270;
+                break;
+            default:
+                break;
+        }
+    }
+
+    long pixXdim = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.PixelXDimension",pixXdim);
+
+    long pixYdim = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.PixelYDimension",pixYdim);
+
+    if (pixXdim !=0 && pixYdim !=0 ) {
+        double ratioExif = pixXdim/(double)pixYdim;
+        double ratioImage = width/(double)height;
+        if (fabs( ratioExif - ratioImage) > 0.1) {
+            // Image has been modified without adjusting exif tags.
+            // Assume user has rotated to upright pose
+            roll = 0;
+        }
+    }
+    
+    //GWP - CCD info was previously computed by the jhead library.  Migration
+    //      to exiv2 means we do it here
+    long eWidth = 0;
+    img.getExiv2Value(exifData,"Exif.Image.ImageWidth",eWidth);
+
+    long eLength = 0;
+    img.getExiv2Value(exifData,"Exif.Image.ImageLength",eLength);
+
+    double sensorPixelWidth = 0;
+    double sensorPixelHeight = 0;
+    if (eWidth > 0 && eLength > 0) {
+        sensorPixelHeight = (double)eLength;
+        sensorPixelWidth = (double)eWidth;
+    } else {
+        // No EXIF information, use number of pixels in image
+        sensorPixelWidth = width;
+        sensorPixelHeight = height;
+    }
+
+    // force landscape sensor orientation
+    if (sensorPixelWidth < sensorPixelHeight ) {
+        double t = sensorPixelWidth;
+        sensorPixelWidth = sensorPixelHeight;
+        sensorPixelHeight = t;
+    }
+
+    DEBUG_DEBUG("sensorPixelWidth: " << sensorPixelWidth);
+    DEBUG_DEBUG("sensorPixelHeight: " << sensorPixelHeight);
+
+    long exifResolutionUnits = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.FocalPlaneResolutionUnit",exifResolutionUnits);
+
+    float resolutionUnits= 0;
+    switch (exifResolutionUnits) {
+        case 3: resolutionUnits = 10.0; break;  //centimeter
+        case 4: resolutionUnits = 1.0; break;   //millimeter
+        case 5: resolutionUnits = .001; break;  //micrometer
+        default: resolutionUnits = 25.4; break; //inches
+    }
+
+    DEBUG_DEBUG("Resolution Units: " << resolutionUnits);
+
+    float fplaneXresolution = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.FocalPlaneXResolution",fplaneXresolution);
+
+    float fplaneYresolution = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.FocalPlaneYResolution",fplaneYresolution);
+
+    float CCDWidth = 0;
+    if (fplaneXresolution != 0) { 
+        CCDWidth = (float)(sensorPixelWidth * resolutionUnits / 
+                fplaneXresolution);
+    }
+
+    float CCDHeight = 0;
+    if (fplaneYresolution != 0) {
+        CCDHeight = (float)(sensorPixelHeight * resolutionUnits /
+              fplaneYresolution) ;
+    }
+
+    DEBUG_DEBUG("CCDHeight:" << CCDHeight);
+    DEBUG_DEBUG("CCDWidth: " << CCDWidth);
+
+    // calc sensor dimensions if not set and 35mm focal length is available
+    FDiff2D sensorSize;
+
+    if (CCDHeight > 0 && CCDWidth > 0) {
+        // read sensor size directly.
+        sensorSize.x = CCDWidth;
+        sensorSize.y = CCDHeight;
+        if (img.getExifModel() == "Canon EOS 20D") {
+            // special case for buggy 20D camera
+            sensorSize.x = 22.5;
+            sensorSize.y = 15;
+        }
+        //
+        // check if sensor size ratio and image size fit together
+        double rsensor = (double)sensorSize.x / sensorSize.y;
+        double rimg = (double) width / height;
+        if ( (rsensor > 1 && rimg < 1) || (rsensor < 1 && rimg > 1) ) {
+            // image and sensor ratio do not match
+            // swap sensor sizes
+            float t;
+            t = sensorSize.y;
+            sensorSize.y = sensorSize.x;
+            sensorSize.x = t;
+        }
+
+        DEBUG_DEBUG("sensorSize.y: " << sensorSize.y);
+        DEBUG_DEBUG("sensorSize.x: " << sensorSize.x);
+
+        cropFactor = sqrt(36.0*36.0+24.0*24.0) /
+            sqrt(sensorSize.x*sensorSize.x + sensorSize.y*sensorSize.y);
+    }
+    
+    DEBUG_DEBUG("cropFactor: " << cropFactor);
+
+    float eFocalLength = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.FocalLength",eFocalLength);
+
+    float eFocalLength35 = 0;
+    img.getExiv2Value(exifData,"Exif.Photo.FocalLengthIn35mmFilm",eFocalLength35);
+
+    //The various methods to detmine crop factor
+    if (eFocalLength > 0 && cropFactor > 0) {
+        // user provided crop factor
+        focalLength = eFocalLength;
+    } else if (eFocalLength35 > 0 && eFocalLength > 0) {
+        cropFactor = eFocalLength35 / eFocalLength;
+        focalLength = eFocalLength;
+    } else if (eFocalLength35 > 0) {
+        // 35 mm equiv focal length available, crop factor unknown.
+        // do not ask for crop factor, assume 1.  Probably a full frame sensor
+        cropFactor = 1;
+        focalLength = eFocalLength35;
+    } else if (eFocalLength > 0 && cropFactor <= 0) {
+        // need to redo, this time with crop
+        focalLength = eFocalLength;
+        cropFactor = 0;
+    }
+#else
     if (ext == "JPG" || ext == "JPEG") {
         
         ImageInfo_t exif;
@@ -380,6 +593,7 @@
             // calc sensor dimensions if not set and 35mm focal length is available
             FDiff2D sensorSize;
             
+             std::cout << "exif.CCDHeight " << exif.CCDHeight << " exif.CCDWidth " << exif.CCDWidth << "\n";
             if (exif.CCDHeight > 0 && exif.CCDWidth > 0) {
                 // read sensor size directly.
                 sensorSize.x = exif.CCDWidth;
@@ -401,6 +615,7 @@
                     sensorSize.y = sensorSize.x;
                     sensorSize.x = t;
                 }
+                std::cout << "sensorSize.y " << sensorSize.y << " sensorSize.x " << sensorSize.x << "\n";
                 cropFactor = sqrt(36.0*36.0+24.0*24)/sqrt(sensorSize.x*sensorSize.x + sensorSize.y*sensorSize.y);
             }
             
@@ -422,15 +637,20 @@
             }
         }
     }
-    
+#endif
+    // Update image with computed values from EXIF
     img.setExifFocalLength(focalLength);
     img.setExifCropFactor(cropFactor);
     img.setRoll(roll);
     
-    
-    
+    DEBUG_DEBUG("Results for:" << filename);
+    DEBUG_DEBUG("Focal Length: " << img.getExifFocalLength());
+    DEBUG_DEBUG("Crop Factor:  " << img.getExifCropFactor());
+    DEBUG_DEBUG("Roll:         " << img.getRoll());
+
     if (focalLength > 0 && cropFactor > 0) {
         img.setHFOV(calcHFOV(img.getProjection(), focalLength, cropFactor, img.getSize()));
+        DEBUG_DEBUG("HFOV:         " << img.getHFOV());
         return true;
     } else {
         return false;
@@ -505,5 +725,34 @@
     }
 }
 
+
+// Convenience functions to work with Exiv2
+bool SrcPanoImage::getExiv2Value(Exiv2::ExifData& exifData, std::string keyName, long & value)
+{
+    Exiv2::ExifKey key(keyName);
+    Exiv2::ExifData::iterator itr = exifData.findKey(key);
+    if (itr != exifData.end()) {
+        value = itr->toLong();
+        DEBUG_DEBUG("" << keyName << ": " << value);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+
+bool SrcPanoImage::getExiv2Value(Exiv2::ExifData& exifData, std::string keyName, float & value)
+{
+    Exiv2::ExifKey key(keyName);
+    Exiv2::ExifData::iterator itr = exifData.findKey(key);
+    if (itr != exifData.end()) {
+        value = itr->toFloat();
+        DEBUG_DEBUG("" << keyName << ": " << value);
+        return true;
+    } else {
+        return false;
+    }
+}
+
     
 } // namespace

Modified: hugin/trunk/src/hugin_base/panodata/SrcPanoImage.h
===================================================================
--- hugin/trunk/src/hugin_base/panodata/SrcPanoImage.h	2008-01-09 16:38:07 UTC (rev 2617)
+++ hugin/trunk/src/hugin_base/panodata/SrcPanoImage.h	2008-01-11 08:38:22 UTC (rev 2618)
@@ -36,6 +36,10 @@
 #include <hugin_utils/utils.h>
 #include <hugin_math/hugin_math.h>
 
+#ifdef HUGIN_USE_EXIV2
+#include <exiv2/exif.hpp>
+#endif
+
 namespace HuginBase {
 
 class Panorama;
@@ -342,8 +346,8 @@
     
     /** calcualte focal length, given crop factor and hfov */
     static double calcFocalLength(SrcPanoImage::Projection proj, double hfov, double crop, vigra::Size2D imageSize);
+
     
-    
 
 private:
     std::string m_filename;
@@ -403,6 +407,13 @@
     unsigned int m_featherWidth;
     // Morph-to-fit using control points.
     bool m_morph;
+
+    /** convenience functions to work with Exiv2 */
+    bool getExiv2Value(Exiv2::ExifData& exifData, std::string keyName, long & value);
+
+    bool getExiv2Value(Exiv2::ExifData& exifData, std::string keyName, float & value);
+
+    
 };
 
 

Modified: hugin/trunk/src/hugin_config.h.in.cmake
===================================================================
--- hugin/trunk/src/hugin_config.h.in.cmake	2008-01-09 16:38:07 UTC (rev 2617)
+++ hugin/trunk/src/hugin_config.h.in.cmake	2008-01-11 08:38:22 UTC (rev 2618)
@@ -50,5 +50,6 @@
 /* Location for XRC files and other data, as defined during configuration*/
 #define INSTALL_XRC_DIR "${INSTALL_XRC_DIR}/"
 
+#cmakedefine HUGIN_USE_EXIV2 1
 
 #endif


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




Thread: [Hugin-cvs] SF.net SVN: hugin: [2618] hugin/trunk (Page 2)

Panorama photo stitcher

hugin-cvs