Exiv2

Hmm, I played a little bit with the exif2 executable v0.24 I just downloaded to avoid errors I might have done myself in handling the library. And all I can say is that the values for ApertureValue and MaxApertureValue I write into the file with exiv2.exe are not the same I read from the jpeg file. However, the value stays the same if I use FNumber.

1. Exif.Image.FNumber SRational 1 F2.8

but:

exiv2 -M"set Exif.Image.MaxApertureValue 28/10" 20150309-DSC04368.jpg
exiv2 -pt -g MaxApertureValue 20150309-DSC04368.jpg
Exif.Image.MaxApertureValue SRational 1 F2.6

I can't imagine that this has something to do with rounding errors through printf's "%f.1"

You're right. Gosh, that can't be presentation. (BTW, we don't use printf).

535 rmills@rmillsmbp:~ $ exiv2 -M"set Exif.Image.MaxApertureValue 28/10" -M"set Exif.Image.FNumber 28/10" ~/R.jpg
536 rmills@rmillsmbp:~ $ exiv2 -pt -g Image.MaxApertureValue -g Image.FNumber ~/R.jpg
Exif.Image.FNumber                           Rational    1  F2.8
Exif.Image.MaxApertureValue                  Rational    1  F2.6
537 rmills@rmillsmbp:~ $ exiv2 -pv -g Image.MaxApertureValue -g Image.FNumber ~/R.jpg
0x829d Image        FNumber                     Rational    1  28/10
0x9205 Image        MaxApertureValue            Rational    1  28/10
538 rmills@rmillsmbp:~ $ 

One of us will have to walk the code in Visual Studio's debugger and find out what's cooking here. Can I ask you to do that and save me a task?

I'm going to add Niels to the watcher's list for this issue. Niels is our makernote engineer and might know about this. Niels is a busy school teacher, so don't expect him to jump on this.

Unfortunately I am unable to build the exe by myself. There is a problem with zlib in my build
and the executable relies on zlib to support png files (if I understand that correctly).
I will try to fix this later, but not today. It's too late now in Germany ;)

Well it's getting late in England and I've been working for about 12 hours on Exiv2 and another open-source project. I'll debug this tomorrow.

I've started with an image with no-meta data.

543 rmills@rmillsmbp:~ $ exiv2 -pa ~/X.jpg
/Users/rmills/X.jpg: (No XMP data found in the file
48 rmills@rmillsmbp:~ $ exiv2 -M"set Exif.Image.MaxApertureValue 28/10" -M"set Exif.Image.FNumber 28/10" ~/X.jpg
549 rmills@rmillsmbp:~ $ exiv2 -pv ~/X.jpg
0x829d Image        FNumber                     Rational    1  28/10
0x9205 Image        MaxApertureValue            Rational    1  28/10
550 rmills@rmillsmbp:~ $ exiv2 -pt ~/X.jpg
Exif.Image.FNumber                           Rational    1  F2.8
Exif.Image.MaxApertureValue                  Rational    1  F2.6

If I don't get back to you in a couple of days, "ping me" as I might forget. I had a new grandson born last week and lots of other stuff happening at the moment.

I've found the reason for MaxApertureValue being displayed as F2.6 for Rational 28/10. The value 2.8 is filtered by this function in tags.cpp

    float fnumber(float apertureValue)
    {
        return static_cast<float>(std::exp(std::log(2.0) * apertureValue / 2));
    }

    std::ostream& print0x9202(std::ostream& os, const Value& value, const ExifData*)
    {
        std::ios::fmtflags f( os.flags() );
        if (   value.count() == 0
            || value.toRational().second == 0) {
            return os << "(" << value << ")";
        }
        std::ostringstream oss;
        oss.copyfmt(os);
        os << "F" << std::setprecision(2) << fnumber(value.toFloat());
        os.copyfmt(oss);
        os.flags(f);
        return os;
    }

I've looked one of my photographs from my Nikon 5300:

524 rmills@rmillsmbp:~/gnu/exiv2/trunk $ exiv2 -pv -g MaxApertureValue ~/Pictures/2015/WinterTrip/Austin/DSC_5850.jpg 
0x9205 Photo        MaxApertureValue            Rational    1  43/10
525 rmills@rmillsmbp:~/gnu/exiv2/trunk $ exiv2 -pt -g MaxApertureValue ~/Pictures/2015/WinterTrip/Austin/DSC_5850.jpg 
Exif.Photo.MaxApertureValue                  Rational    1  F4.4
526 rmills@rmillsmbp:~/gnu/exiv2/trunk $  

The function float fnumber(float apertureValue) is called in 3 files: cannon.cpp, crwimage.cpp and tags.cpp. So there must be a relationship between the stored data and the presentation value.

I'm going to add Phil and Andreas to the watchers of this issue as they may be able to explain this. And I have two suggestions for you:

1. Replicate this behaviour with ExifTool and ask on their Forum.
2. Start Googling and discover more about Aperture/FNumbers

I'm not going to mark this "Resolved" at the moment, however I don't believe I can do anything else about this.

Here's a graph of the non-linear function:

Final thought about this. I've run my image on ExifTool and exiv2. The results are the same:

533 rmills@rmillsmbp:~/clanmills $ ExifTool ~/Pictures/2015/WinterTrip/Austin/DSC_5850.jpg  | grep -i aperture
Max Aperture Value              : 4.4
AF Aperture                     : 4.6
Max Aperture At Min Focal       : 3.6
Max Aperture At Max Focal       : 6.3
Effective Max Aperture          : 4.5
Aperture                        : 4.5
534 rmills@rmillsmbp:~/clanmills $ exiv2 -pt ~/Pictures/2015/WinterTrip/Austin/DSC_5850.jpg  | grep -i aperture
Exif.Photo.MaxApertureValue                  Rational    1  F4.4
Exif.NikonLd3.AFAperture                     Byte        1  F4.6
Exif.NikonLd3.MaxApertureAtMinFocal          Byte        1  F3.6
Exif.NikonLd3.MaxApertureAtMaxFocal          Byte        1  F6.3
Exif.NikonLd3.EffectiveMaxAperture           Byte        1  F4.5
535 rmills@rmillsmbp:~/clanmills $ $ exiv2 -pv ~/Pictures/2015/WinterTrip/Austin/DSC_5850.jpg  | grep -i aperture
0x9205 Photo        MaxApertureValue            Rational    1  43/10
0x0005 NikonLd3     AFAperture                  Byte        1  53
0x0010 NikonLd3     MaxApertureAtMinFocal       Byte        1  44
0x0011 NikonLd3     MaxApertureAtMaxFocal       Byte        1  64
0x0013 NikonLd3     EffectiveMaxAperture        Byte        1  52
536 rmills@rmillsmbp:~/clanmills $ 

The "ApertureValue" tags are stored as APEX values but converted to F-stops for display. There are two reasons for doing this: 1) F-stops are much more familiar than APEX values, and 2) This facilitates copying between aperture tags stored in different representations.

Thanks very much for taking the time and look into it.
Although I was not very satisfied with your answers ;) you pointed me in the right direction.

So, instead of tossing the real FNumber into the EXIV2::Rational(x, y) to tag the
image with ApertureValue and MaxApertureValue I now do something like this:

...
double d = std::floor( ((std::log(F-STOP-VALUE) / std::log(2)) * 2) + 0.5);
int numerator = static_cast<int>(d) * 10;
exifData["Exif.Image.ApertureValue"] = Exiv2::Rational(numerator, 10);
...

That way all works flawlessly (well, I ignore those little rounding errors...)
I tested this against exiv2 (yes, build now with the executable), exiftool and Irfanview.

Torsten

I wouldn't be satisfied either if I had to do the APEX conversion manually. One might think that Exiv2 should do this automatically (to make reading and writing symmetrical).

I'm not sure how to turn your dissatisfaction into action to make you happy!

If I were to modify exiv2 to parse Ffloat -> Rational(numerator,10) using your function, would that help?

622 rmills@rmillsmbp:/Applications $ exiv2 -pa -g Photo.MaxApertureValue ~/R.jpg
Exif.Photo.MaxApertureValue                  Rational    1  F3.5
623 rmills@rmillsmbp:/Applications $ exiv2 -M"set Exif.Photo.MaxApertureValue F4.3" ~/R.jpg
Warning: Exif.Photo.MaxApertureValue: Failed to read Rational value "F4.3" 
624 rmills@rmillsmbp:/Applications $ exiv2 -pa -g Photo.MaxApertureValue ~/R.jpg
Exif.Photo.MaxApertureValue                  Rational    1  F3.5
625 rmills@rmillsmbp:/Applications $

Is that the fix that you would like to see implemented?

Hmm, I am absolutely happy with my solution ;-) So there is no need to fix something I
was probably the only one who has a problem with. I shared my solution so it migth be
helpful for somebody else.

Hi Robin,

Your solution sounds good, but the implementation in types.cpp level worries me because it sounds too general. I am not familiar with the Exiv2 code, but you should be sure that the APEX conversion applies only to the ApertureValue tags.

Thanks, Phil. You are right. It is general and I'm extending the syntax of Rational to be either n/m or Fnumber. I'll document this in the man page and explain about the APEX values. Anyone using the Fnumber syntax for anything other than aperture does so at their own peril. The current Exiv2 will report an error for Fnumber, so no existing scripts will be broken by this change.

I could of course add a flag in the code to say which keys accept the Fnumber syntax, however I don't believe we need this. If I clearly document Fnumber, this should be sufficient.

Sounds good to me.

Fix submitted. r3621 and r3622 Thank You to Torsten for reporting this issue. Thank You to Phil for his explanation and encouragement.

I think it's OK to provide the Fnumber syntax for general use because man page already says:

It is possible to write tags with types and values different from those
specified in the standards, duplicate Exif tags, undefined tags, or incomplete metadata.
While exiv2 is able to read all metadata that it can write, other programs may have difficulties
with images that contain non standard-conforming metadata.

The submitted code avoids struggles with the denominator as follows:

    std::istream& operator>>(std::istream& is, Rational& r)
    {
        // http://dev.exiv2.org/boards/3/topics/1912?r=1915
        if ( std::tolower(is.peek()) == 'f' ) {
            char  F;
            float f;
            is >> F >> f ;
            f  = 2.0f * std::log(f) / std::log(2.0f) ;
            r  = Exiv2::floatToRationalCast(f);
        } else {
            int32_t nominator;
            int32_t denominator;
            char c('\0');
            is >> nominator >> c >> denominator;
            if (c != '/') is.setstate(std::ios::failbit);
            if (is) r = std::make_pair(nominator, denominator);
        }
        return is;
    }

755 rmills@rmillsmbp:~/gnu/exiv2/trunk $ for f in 2.6 5.6 7.1 13 22; do \
  exiv2 "-Mset Exif.Photo.MaxApertureValue F$f" ~/X.jpg  \
  exiv2 -pv -g Photo.MaxApertureValue ~/X.jpg \
  exiv2 -pa -g Photo.MaxApertureValue ~/X.jpg \
done
0x9205 Photo        MaxApertureValue            Rational    1  2757023/1000000
Exif.Photo.MaxApertureValue                  Rational    1  F2.6
0x9205 Photo        MaxApertureValue            Rational    1  2485427/500000
Exif.Photo.MaxApertureValue                  Rational    1  F5.6
0x9205 Photo        MaxApertureValue            Rational    1  2827819/500000
Exif.Photo.MaxApertureValue                  Rational    1  F7.1
0x9205 Photo        MaxApertureValue            Rational    1  92511/12500
Exif.Photo.MaxApertureValue                  Rational    1  F13
0x9205 Photo        MaxApertureValue            Rational    1  557429/62500
Exif.Photo.MaxApertureValue                  Rational    1  F22
756 rmills@rmillsmbp:~/gnu/exiv2/trunk $ 

I've updated the man page as follows:

The format for Rational (and SRational) is one of:

• integer
• integer-numerator/integer-denominator
• Number
• fnumber

Examples:

$ exiv2 "-Mset Exif.Photo.MaxApertureValue 557429/62500" X.jpg
$ exiv2 "-Mset Exif.Photo.MaxApertureValue F5.6" X.jpg

The format Fnumber is for the convenience of setting aperture values. The aperture value stored in Exif is an APEX value which can be evaluated by the expression::

• apex-value = log(Fnumber) * 2.0 / log(2.0)
• Fnumber = exp(apex-value * log(2.0) / 2)

The Fnumber syntax is valid for any Rational, even when the key is not an Aperture.

More information about APEX is available from: http://en.wikipedia.org/wiki/APEX_system