Apache Commons Imaging (EXIF): Setting tags/tags missing

Question

I'm using the Apache Commons Imaging library (Java 8, you can find my code here) and I've come across a few problems with tags:

If I open the image info of e.g. this .jpg file with Win 10, there are "Origin" tags, e.g. "Authors" and "Date acquired":

You can find a list of EXIF tags here and it includes the "Authors" one and also an additional "Artist" one. The "Artist" tag seemed to have existed in the library at one point (source) but the apidocs don't list it anymore and ExifTagConstants.TIFF_TAG_ARTIST doesn't exist. Same thing with the "GPSAltitude" tag: It should exist according to the EXIF list but I can't seem to find it in the library.

I tried to use the "Maker" tag instead:

final TiffOutputDirectory exifDir = outputSet.getOrCreateExifDirectory();
exifDir.removeField(ExifTagConstants.EXIF_TAG_MAKER_NOTE);
exifDir.add(ExifTagConstants.EXIF_TAG_MAKER_NOTE, "Test Maker");

But ExifTagConstants.EXIF_TAG_MAKER_NOTE's type of TagInfoUndefineds doesn't seem to be valid for exifDir.add.

I also tried to add the date:

exifDir.removeField(ExifTagConstants.EXIF_TAG_DATE_TIME_DIGITIZED);
exifDir.add(ExifTagConstants.EXIF_TAG_DATE_TIME_DIGITIZED, "1970/01/01");

This just throws an exception:

org.apache.commons.imaging.ImageWriteException: Tag expects 20 byte(s), not 1

The only tag I've managed to successfully write so far is ExifTagConstants.EXIF_TAG_USER_COMMENT.

How do I use/write these tags (author/artist, date, altitude,...)?

Edit:

I managed to find two of the tags:

exifDir.add(MicrosoftTagConstants.EXIF_TAG_XPAUTHOR, "Test Author");//Author
exifDir.add(GpsTagConstants.GPS_TAG_GPS_ALTITUDE, new RationalNumber(3, 1));//Altitude

... but they aren't written into the file.

exifDir.add(ExifTagConstants.EXIF_TAG_USER_COMMENT, "my comment");

works, so I know it's actually writing tags, it just doesn't work for the two above. Any idea what's wrong?

Answer 1

As @haraldK already mentioned: GPS data isn't part of the actual EFIX directory, which is also the case in the "Apache Commons Imaging" library.

So instead of writing the altitude with

double someDouble = 123.123456789;
int alt = (int) Math.round(someDouble*1000); //round to 3 decimal places
final TiffOutputDirectory exifDir = outputSet.getOrCreateExifDirectory();
exifDir.removeField(GpsTagConstants.GPS_TAG_GPS_ALTITUDE);
exifDir.add(GpsTagConstants.GPS_TAG_GPS_ALTITUDE, new RationalNumber(alt, 1000));

use:

final TiffOutputDirectory gpsDir = outputSet.getOrCreateGPSDirectory();
gpsDir.removeField(GpsTagConstants.GPS_TAG_GPS_ALTITUDE);
gpsDir.add(GpsTagConstants.GPS_TAG_GPS_ALTITUDE, new RationalNumber(alt, 1000));

This will write "123.123" into the "Altitude" field that can be viewed through the Windows Explorer (right-click on image -> Properties -> Details).

As for the other tags:

final TiffOutputDirectory exifDir = outputSet.getOrCreateExifDirectory();
final TiffOutputDirectory gpsDir = outputSet.getOrCreateGPSDirectory();
final TiffOutputDirectory rootDir = outputSet.getOrCreateRootDirectory();
final TiffOutputDirectory intDir = outputSet.getInteroperabilityDirectory(); //Not sure what this one is used for

//Writing into the "Authors" field
rootDir.removeField(MicrosoftTagConstants.EXIF_TAG_XPAUTHOR);
rootDir.add(MicrosoftTagConstants.EXIF_TAG_XPAUTHOR, "Me");

//Writing into the "Program Name" field
rootDir.removeField(ExifTagConstants.EXIF_TAG_SOFTWARE);
rootDir.add(ExifTagConstants.EXIF_TAG_SOFTWARE, "My App");

//Writing into the "Date taken" field
exifDir.removeField(ExifTagConstants.EXIF_TAG_DATE_TIME_ORIGINAL);
exifDir.add(ExifTagConstants.EXIF_TAG_DATE_TIME_ORIGINAL, "1970:01:01 12:34:56");

//Writing into the "Digitized Date"
exifDir.removeField(ExifTagConstants.EXIF_TAG_DATE_TIME_DIGITIZED);
exifDir.add(ExifTagConstants.EXIF_TAG_DATE_TIME_DIGITIZED, "1970:01:01 12:34:56");
//Not visible in "Properties" (use image editing software to see it)

//Writing the GPS time stamp
gpsDir.removeField(GpsTagConstants.GPS_TAG_GPS_DATE_STAMP);
gpsDir.add(GpsTagConstants.GPS_TAG_GPS_DATE_STAMP, "1970:01:01");
//Apparently only writes year & not visible in "Properties" (use image editing software to see it)

I haven't found the right tag for "Date Acquired" yet, so if someone knows the exact one, please comment on this answer.

Answer 2

Old way to go : You can looking at a specification of EXIF metadatas and you can implement some custom parsing to get them with How to extract EXIF metadatas from JPEG files.

Recent way to go : You can read EXIF datas with that ImageData class which is working very well

Now if you want to modify/update the images metadatas, you can use the documentation in which you will find the following method :

        /**
48       * This example illustrates how to add/update EXIF metadata in a JPEG file.
49       *
50       * @param jpegImageFile
51       *            A source image file.
52       * @param dst
53       *            The output file.
54       * @throws IOException
55       * @throws ImageReadException
56       * @throws ImageWriteException
57       */
58      public void changeExifMetadata(final File jpegImageFile, final File dst)
59              throws IOException, ImageReadException, ImageWriteException {
60  
61          try (FileOutputStream fos = new FileOutputStream(dst);
62                  OutputStream os = new BufferedOutputStream(fos);) {
63  
64              TiffOutputSet outputSet = null;
65  
66              // note that metadata might be null if no metadata is found.
67              final ImageMetadata metadata = Imaging.getMetadata(jpegImageFile);
68              final JpegImageMetadata jpegMetadata = (JpegImageMetadata) metadata;
69              if (null != jpegMetadata) {
70                  // note that exif might be null if no Exif metadata is found.
71                  final TiffImageMetadata exif = jpegMetadata.getExif();
72  
73                  if (null != exif) {
74                      // TiffImageMetadata class is immutable (read-only).
75                      // TiffOutputSet class represents the Exif data to write.
76                      //
77                      // Usually, we want to update existing Exif metadata by
78                      // changing
79                      // the values of a few fields, or adding a field.
80                      // In these cases, it is easiest to use getOutputSet() to
81                      // start with a "copy" of the fields read from the image.
82                      outputSet = exif.getOutputSet();
83                  }
84              }
85  
86              // if file does not contain any exif metadata, we create an empty
87              // set of exif metadata. Otherwise, we keep all of the other
88              // existing tags.
89              if (null == outputSet) {
90                  outputSet = new TiffOutputSet();
91              }
92  
93              {
94                  // Example of how to add a field/tag to the output set.
95                  //
96                  // Note that you should first remove the field/tag if it already
97                  // exists in this directory, or you may end up with duplicate
98                  // tags. See above.
99                  //
100                 // Certain fields/tags are expected in certain Exif directories;
101                 // Others can occur in more than one directory (and often have a
102                 // different meaning in different directories).
103                 //
104                 // TagInfo constants often contain a description of what
105                 // directories are associated with a given tag.
106                 //
107                 final TiffOutputDirectory exifDirectory = outputSet.getOrCreateExifDirectory();
108                 // make sure to remove old value if present (this method will
109                 // not fail if the tag does not exist).
110                 exifDirectory.removeField(ExifTagConstants.EXIF_TAG_APERTURE_VALUE);
111                 exifDirectory.add(ExifTagConstants.EXIF_TAG_APERTURE_VALUE,
112                         new RationalNumber(3, 10));
113             }
114 
115             {
116                 // Example of how to add/update GPS info to output set.
117 
118                 // New York City
119                 final double longitude = -74.0; // 74 degrees W (in Degrees East)
120                 final double latitude = 40 + 43 / 60.0; // 40 degrees N (in Degrees
121                 // North)
122 
123                 outputSet.setGPSInDegrees(longitude, latitude);
124             }
125 
126             // printTagValue(jpegMetadata, TiffConstants.TIFF_TAG_DATE_TIME);
127 
128             new ExifRewriter().updateExifMetadataLossless(jpegImageFile, os,
129                     outputSet);
130         }
131     }

I have just found a usefull example for your use case I think. You will know now how to find them, I am sure it will be easier to modify them :

@Override
public Exif getExif(Photo photo) throws ServiceException {
    File file = new File(photo.getPath());
    String exposure = "not available";
    double aperture = 0.0;
    double focalLength = 0.0;
    int iso = 0;
    boolean flash = false;
    String make = "not available";
    String model = "not available";
    double altitude = 0.0;

    try {
        final ImageMetadata metadata = Imaging.getMetadata(file);
        final JpegImageMetadata jpegMetadata = (JpegImageMetadata) metadata;

        if (jpegMetadata.findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_EXPOSURE_TIME)
                != null) {
            exposure = jpegMetadata
                    .findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_EXPOSURE_TIME)
                    .getValueDescription().split(" ")[0];
        }

        if (jpegMetadata.findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_APERTURE_VALUE)
                != null) {
            aperture = jpegMetadata
                    .findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_APERTURE_VALUE)
                    .getDoubleValue();
        }
        if (jpegMetadata.findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_FOCAL_LENGTH)
                != null) {
            focalLength = jpegMetadata
                    .findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_FOCAL_LENGTH)
                    .getDoubleValue();
        }
        if (jpegMetadata.findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_ISO) != null) {
            iso = jpegMetadata.findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_ISO)
                    .getIntValue();
        }

        if (jpegMetadata.findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_FLASH) != null) {
            flash = jpegMetadata.findEXIFValueWithExactMatch(ExifTagConstants.EXIF_TAG_FLASH)
                    .getIntValue() != 0;
        }

        if (jpegMetadata.findEXIFValueWithExactMatch(TiffTagConstants.TIFF_TAG_MAKE) != null) {
            make = jpegMetadata.findEXIFValueWithExactMatch(TiffTagConstants.TIFF_TAG_MAKE)
                    .getValueDescription();
        }
        if (jpegMetadata.findEXIFValueWithExactMatch(TiffTagConstants.TIFF_TAG_MODEL) != null) {
            model = jpegMetadata.findEXIFValueWithExactMatch(TiffTagConstants.TIFF_TAG_MODEL)
                    .getValueDescription();
        }

        if (jpegMetadata.findEXIFValueWithExactMatch(GpsTagConstants.GPS_TAG_GPS_ALTITUDE)
                != null) {
            altitude = jpegMetadata
                    .findEXIFValueWithExactMatch(GpsTagConstants.GPS_TAG_GPS_ALTITUDE)
                    .getDoubleValue();
        }

        return new Exif(photo.getId(), exposure, aperture, focalLength, iso, flash, make, model,
                altitude);
    } catch (IOException | ImageReadException e) {
        throw new ServiceException(e.getMessage(), e);
    }
}

Answer 3

I found the Artist Tag:

exifDirectory.add(TiffTagConstants.TIFF_TAG_ARTIST, "JANE DOUGH");

Haven't tested whether this will work though.

EDIT:

It works well.

Online Exif Viewer Image

The image shows that the Artist Tag works.