exif-aerial 2.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b754c96357d99e596c4198ceaff8a2e5e19a7795
+  data.tar.gz: 665d875fe1b752a1c9d098f53aef4dd881bcc87f
+SHA512:
+  metadata.gz: 675e3119813060ff79e91235eda0ac173435a679adbd90359055e9951195d484708526c23ad70dcaa3e2625c60c884aaa564aa289a8184a124896a452f581af9
+  data.tar.gz: 91c3ea8a3a4b831814fc84743bea5c9ff94e6b87a1b58c54fb91477059b3c8e5a523131f63aa31b85ba9e087a79d2f1c8a7ed67ed2b2ee4f3a15341348e9b786

data/ext/exif/data.c

@@ -0,0 +1,348 @@
+#include "data.h"
+#include "ruby.h"
+
+#include <libexif/exif-data.h>
+#include <libexif/exif-loader.h>
+#include <stdint.h>
+#include <time.h>
+
+extern VALUE rb_mExif, rb_eNotReadble, rb_eIFDNotFound;
+extern const char *exif_entry_to_ivar(ExifEntry *entry);
+
+VALUE rb_cExifData;
+static const char *ifd_name_mapping[] = {"ifd0", "ifd1", "exif", "gps",
+                                         "interoperability"};
+static const char *attr_readers[] = {"ifds",
+                                     "aperture_value",
+                                     "artist",
+                                     "battery_level",
+                                     "bits_per_sample",
+                                     "brightness_value",
+                                     "cfa_pattern",
+                                     "cfa_repeat_pattern_dim",
+                                     "color_space",
+                                     "components_configuration",
+                                     "compressed_bits_per_pixel",
+                                     "compression",
+                                     "contrast",
+                                     "copyright",
+                                     "custom_rendered",
+                                     "date_time",
+                                     "date_time_digitized",
+                                     "date_time_original",
+                                     "device_setting_description",
+                                     "digital_zoom_ratio",
+                                     "document_name",
+                                     "exif_ifd_pointer",
+                                     "exif_version",
+                                     "exposure_bias_value",
+                                     "exposure_index",
+                                     "exposure_mode",
+                                     "exposure_program",
+                                     "exposure_time",
+                                     "file_source",
+                                     "fill_order",
+                                     "flash",
+                                     "flash_energy",
+                                     "flash_pix_version",
+                                     "fnumber",
+                                     "focal_length",
+                                     "focal_length_in_35mm_film",
+                                     "focal_plane_resolution_unit",
+                                     "focal_plane_x_resolution",
+                                     "focal_plane_y_resolution",
+                                     "gain_control",
+                                     "gamma",
+                                     "gps_altitude",
+                                     "gps_altitude_ref",
+                                     "gps_area_information",
+                                     "gps_date_stamp",
+                                     "gps_dest_bearing",
+                                     "gps_dest_bearing_ref",
+                                     "gps_dest_distance",
+                                     "gps_dest_distance_ref",
+                                     "gps_dest_latitude",
+                                     "gps_dest_latitude_ref",
+                                     "gps_dest_longitude",
+                                     "gps_dest_longitude_ref",
+                                     "gps_differential",
+                                     "gps_dop",
+                                     "gps_img_direction",
+                                     "gps_img_direction_ref",
+                                     "gps_info_ifd_pointer",
+                                     "gps_latitude",
+                                     "gps_latitude_ref",
+                                     "gps_longitude",
+                                     "gps_longitude_ref",
+                                     "gps_map_datum",
+                                     "gps_measure_mode",
+                                     "gps_processing_method",
+                                     "gps_satellites",
+                                     "gps_speed",
+                                     "gps_speed_ref",
+                                     "gps_status",
+                                     "gps_time_stamp",
+                                     "gps_track",
+                                     "gps_track_ref",
+                                     "gps_version_id",
+                                     "image_description",
+                                     "image_length",
+                                     "image_resources",
+                                     "image_unique_id",
+                                     "image_width",
+                                     "inter_color_profile",
+                                     "interoperability_ifd_pointer",
+                                     "interoperability_index",
+                                     "interoperability_version",
+                                     "iptc_naa",
+                                     "iso_speed_ratings",
+                                     "jpeg_interchange_format",
+                                     "jpeg_interchange_format_length",
+                                     "jpeg_proc",
+                                     "light_source",
+                                     "make",
+                                     "maker_note",
+                                     "max_aperture_value",
+                                     "metering_mode",
+                                     "model",
+                                     "new_cfa_pattern",
+                                     "new_subfile_type",
+                                     "oecf",
+                                     "orientation",
+                                     "padding",
+                                     "photometric_interpretation",
+                                     "pixel_x_dimension",
+                                     "pixel_y_dimension",
+                                     "planar_configuration",
+                                     "primary_chromaticities",
+                                     "print_image_matching",
+                                     "reference_black_white",
+                                     "related_image_file_format",
+                                     "related_image_length",
+                                     "related_image_width",
+                                     "related_sound_file",
+                                     "resolution_unit",
+                                     "rows_per_strip",
+                                     "samples_per_pixel",
+                                     "saturation",
+                                     "scene_capture_type",
+                                     "scene_type",
+                                     "sensing_method",
+                                     "sharpness",
+                                     "shutter_speed_value",
+                                     "software",
+                                     "spatial_frequency_response",
+                                     "spectral_sensitivity",
+                                     "strip_byte_counts",
+                                     "strip_offsets",
+                                     "sub_ifds",
+                                     "sub_sec_time",
+                                     "sub_sec_time_digitized",
+                                     "sub_sec_time_original",
+                                     "subject_area",
+                                     "subject_distance",
+                                     "subject_distance_range",
+                                     "subject_location",
+                                     "tiff_ep_standard_id",
+                                     "time_zone_offset",
+                                     "transfer_function",
+                                     "transfer_range",
+                                     "user_comment",
+                                     "white_balance",
+                                     "white_point",
+                                     "x_resolution",
+                                     "xml_packet",
+                                     "xp_author",
+                                     "xp_comment",
+                                     "xp_keywords",
+                                     "xp_subject",
+                                     "xp_title",
+                                     "y_resolution",
+                                     "ycbcr_coefficients",
+                                     "ycbcr_positioning",
+                                     "ycbcr_sub_sampling"};
+
+static VALUE new (VALUE self, VALUE input);
+static VALUE dump(VALUE self);
+static VALUE brackets(VALUE self, VALUE ifd_symbol);
+static void each_content(ExifContent *ec, void *user_data);
+static void each_entry(ExifEntry *, void *user_data);
+static VALUE exif_entry_to_rb_value(ExifEntry *);
+static VALUE rational_to_num(ExifRational rational);
+static VALUE srational_to_num(ExifSRational srational);
+
+void init_data() {
+  int length;
+
+  rb_cExifData = rb_define_class_under(rb_mExif, "Data", rb_cObject);
+  length = sizeof(attr_readers) / sizeof(char *);
+  for (int i = 0; i < length; ++i)
+    rb_define_attr(rb_cExifData, attr_readers[i], 1, 0);
+  rb_define_alias(rb_cExifData, "to_h", "ifds");
+  rb_define_singleton_method(rb_cExifData, "new", new, 1);
+  rb_define_method(rb_cExifData, "dump", dump, 0);
+  rb_define_method(rb_cExifData, "[]", brackets, 1);
+}
+
+VALUE new (VALUE self, VALUE input) {
+  ExifData *ed;
+  VALUE read_data;
+
+  switch (TYPE(input)) {
+  case T_STRING:
+    read_data = input;
+    break;
+  case T_FILE:
+    read_data = rb_funcall(input, rb_intern("read"), 0);
+    break;
+  default:
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected String or IO)",
+             rb_obj_classname(input));
+  }
+
+  ExifLoader *loader = exif_loader_new();
+  exif_loader_write(loader, (unsigned char *)RSTRING_PTR(read_data),
+                    RSTRING_LEN(read_data));
+  ed = exif_loader_get_data(loader);
+  exif_loader_unref(loader);
+  if (!ed)
+    rb_raise(rb_eNotReadble, "File not readable or no EXIF data in file.");
+
+  VALUE rb_data = Data_Wrap_Struct(self, NULL, exif_data_free, ed);
+  rb_iv_set(rb_data, "@ifds", rb_hash_new());
+  exif_data_foreach_content(ed, each_content, &rb_data);
+  return rb_data;
+}
+
+static VALUE dump(VALUE self) {
+  ExifData *ed;
+  Data_Get_Struct(self, ExifData, ed);
+  exif_data_dump(ed);
+  return Qnil;
+}
+
+static VALUE brackets(VALUE self, VALUE ifd_symbol) {
+  return rb_hash_aref(rb_iv_get(self, "@ifds"), ifd_symbol);
+}
+
+static void each_content(ExifContent *ec, void *self_ptr) {
+  VALUE *self;
+  ExifIfd ifd;
+
+  ifd = exif_content_get_ifd(ec);
+  if (ifd == EXIF_IFD_COUNT)
+    rb_raise(rb_eIFDNotFound, "Con't get IFD.");
+  rb_hash_aset(rb_iv_get(*(VALUE *)self_ptr, "@ifds"),
+               ID2SYM(rb_intern(ifd_name_mapping[ifd])), rb_hash_new());
+  exif_content_foreach_entry(ec, each_entry, self_ptr);
+}
+
+static void each_entry(ExifEntry *entry, void *self_ptr) {
+  VALUE value;
+  const char *ivar_name;
+
+  ivar_name = exif_entry_to_ivar(entry);
+  value = exif_entry_to_rb_value(entry);
+  rb_hash_aset(rb_hash_aref(rb_iv_get(*(VALUE *)self_ptr, "@ifds"),
+                            ID2SYM(rb_intern(
+                                ifd_name_mapping[exif_entry_get_ifd(entry)]))),
+               ID2SYM(rb_intern(ivar_name + 1)), value);
+  if (TYPE(rb_ivar_defined(*(VALUE *)self_ptr, rb_intern(ivar_name))) ==
+      T_FALSE) {
+    rb_iv_set(*(VALUE *)self_ptr, ivar_name, value);
+  }
+}
+
+#define TYPECAST(value1, value2)                                               \
+  do {                                                                         \
+    if (entry->components > 1) {                                               \
+      ret = rb_ary_new2(entry->components);                                    \
+      for (i = 0; i < entry->components; i++)                                  \
+        rb_ary_push(ret, value1);                                              \
+    } else                                                                     \
+      ret = value2;                                                            \
+  } while (0)
+
+#define TYPECAST_BYTE(c_to_rb, type)                                           \
+  TYPECAST(c_to_rb((type)entry->data[i]), c_to_rb((type)entry->data[0]))
+
+#define TYPECAST_EXIF(c_to_rb, exif_get)                                       \
+  TYPECAST(c_to_rb(exif_get_##exif_get(entry->data + i * size, order)),        \
+           c_to_rb(exif_get_##exif_get(entry->data, order)))
+
+static VALUE exif_entry_to_rb_value(ExifEntry *entry) {
+  ExifData *data;
+  ExifByteOrder order;
+  ExifRational rational;
+  ExifSRational srational;
+  VALUE ret;
+  size_t len, i;
+  unsigned char size;
+
+  data = entry->parent->parent;
+  order = exif_data_get_byte_order(data);
+  ret = Qnil;
+  size = exif_format_get_size(entry->format);
+
+  switch (entry->format) {
+  case EXIF_FORMAT_UNDEFINED:
+    ret = rb_str_new((const char *)entry->data, entry->size);
+    break;
+  case EXIF_FORMAT_BYTE:
+    TYPECAST_BYTE(INT2FIX, uint8_t);
+  case EXIF_FORMAT_SBYTE:
+    TYPECAST_BYTE(INT2FIX, int8_t);
+    break;
+  case EXIF_FORMAT_SHORT:
+    TYPECAST_EXIF(INT2FIX, short);
+    break;
+  case EXIF_FORMAT_SSHORT:
+    TYPECAST_EXIF(INT2FIX, sshort);
+    break;
+  case EXIF_FORMAT_LONG:
+    TYPECAST_EXIF(ULONG2NUM, long);
+    break;
+  case EXIF_FORMAT_SLONG:
+    TYPECAST_EXIF(LONG2NUM, slong);
+    break;
+  case EXIF_FORMAT_ASCII:
+    ret = rb_str_new2((const char *)entry->data);
+    break;
+  case EXIF_FORMAT_RATIONAL:
+    TYPECAST_EXIF(rational_to_num, rational);
+    break;
+  case EXIF_FORMAT_SRATIONAL:
+    TYPECAST_EXIF(srational_to_num, srational);
+    break;
+  case EXIF_FORMAT_DOUBLE:
+  case EXIF_FORMAT_FLOAT:
+    ret = rb_float_new(*(double *)entry->data);
+    break;
+  }
+
+  return ret;
+}
+
+#undef TYPECAST
+#undef TYPECAST_BYTE
+#undef TYPECAST_EXIF
+
+VALUE rational_to_num(ExifRational rational) {
+  if (rational.numerator == 0 && rational.denominator == 0)
+    return DBL2NUM(NAN);
+  else if (rational.denominator == 0)
+    return DBL2NUM(INFINITY);
+  else
+    return rb_rational_new(ULONG2NUM(rational.numerator),
+                           ULONG2NUM(rational.denominator));
+}
+
+VALUE srational_to_num(ExifSRational srational) {
+  if (srational.numerator == 0 && srational.denominator == 0)
+    return DBL2NUM(NAN);
+  else if (srational.denominator == 0)
+    return DBL2NUM(srational.numerator > 0 ? INFINITY : -INFINITY);
+  else
+    return rb_rational_new(LONG2NUM(srational.numerator),
+                           LONG2NUM(srational.denominator));
+}

data/ext/exif/data.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void init_data();

data/ext/exif/exif.c

@@ -0,0 +1,16 @@
+#include "data.h"
+#include "ruby.h"
+
+VALUE rb_mExif, rb_eError, rb_eNotReadble, rb_eIFDNotFound, rb_eUnknownDataType;
+
+void Init_exif(void) {
+  rb_mExif = rb_define_module("Exif");
+
+  rb_eError = rb_define_class_under(rb_mExif, "Error", rb_eStandardError);
+  rb_eNotReadble = rb_define_class_under(rb_mExif, "NotReadble", rb_eError);
+  rb_eIFDNotFound = rb_define_class_under(rb_mExif, "IFDNotFound", rb_eError);
+  rb_eUnknownDataType =
+      rb_define_class_under(rb_mExif, "UnknownDataType", rb_eError);
+
+  init_data();
+}

data/ext/exif/exif_entry_to_ivar.c

@@ -0,0 +1,452 @@
+#include <libexif/exif-entry.h>
+
+const char *exif_entry_to_ivar(ExifEntry *ee) {
+  ExifIfd ifd;
+  ExifTag tag;
+
+  ifd = exif_entry_get_ifd(ee);
+  tag = ee->tag;
+
+  switch ((int)tag) {
+  case EXIF_TAG_INTEROPERABILITY_INDEX: /* EXIF_TAG_GPS_LATITUDE_REF */
+    return ifd == EXIF_IFD_GPS ? "@gps_latitude_ref"
+                               : "@interoperability_index";
+    break;
+  case EXIF_TAG_INTEROPERABILITY_VERSION: /* EXIF_TAG_GPS_LATITUDE */
+    return ifd == EXIF_IFD_GPS ? "@gps_latitude" : "@interoperability_version";
+    break;
+  case EXIF_TAG_NEW_SUBFILE_TYPE:
+    return "@new_subfile_type";
+    break;
+  case EXIF_TAG_IMAGE_WIDTH:
+    return "@image_width";
+    break;
+  case EXIF_TAG_IMAGE_LENGTH:
+    return "@image_length";
+    break;
+  case EXIF_TAG_BITS_PER_SAMPLE:
+    return "@bits_per_sample";
+    break;
+  case EXIF_TAG_COMPRESSION:
+    return "@compression";
+    break;
+  case EXIF_TAG_PHOTOMETRIC_INTERPRETATION:
+    return "@photometric_interpretation";
+    break;
+  case EXIF_TAG_FILL_ORDER:
+    return "@fill_order";
+    break;
+  case EXIF_TAG_DOCUMENT_NAME:
+    return "@document_name";
+    break;
+  case EXIF_TAG_IMAGE_DESCRIPTION:
+    return "@image_description";
+    break;
+  case EXIF_TAG_MAKE:
+    return "@make";
+    break;
+  case EXIF_TAG_MODEL:
+    return "@model";
+    break;
+  case EXIF_TAG_STRIP_OFFSETS:
+    return "@strip_offsets";
+    break;
+  case EXIF_TAG_ORIENTATION:
+    return "@orientation";
+    break;
+  case EXIF_TAG_SAMPLES_PER_PIXEL:
+    return "@samples_per_pixel";
+    break;
+  case EXIF_TAG_ROWS_PER_STRIP:
+    return "@rows_per_strip";
+    break;
+  case EXIF_TAG_STRIP_BYTE_COUNTS:
+    return "@strip_byte_counts";
+    break;
+  case EXIF_TAG_X_RESOLUTION:
+    return "@x_resolution";
+    break;
+  case EXIF_TAG_Y_RESOLUTION:
+    return "@y_resolution";
+    break;
+  case EXIF_TAG_PLANAR_CONFIGURATION:
+    return "@planar_configuration";
+    break;
+  case EXIF_TAG_RESOLUTION_UNIT:
+    return "@resolution_unit";
+    break;
+  case EXIF_TAG_TRANSFER_FUNCTION:
+    return "@transfer_function";
+    break;
+  case EXIF_TAG_SOFTWARE:
+    return "@software";
+    break;
+  case EXIF_TAG_DATE_TIME:
+    return "@date_time";
+    break;
+  case EXIF_TAG_ARTIST:
+    return "@artist";
+    break;
+  case EXIF_TAG_WHITE_POINT:
+    return "@white_point";
+    break;
+  case EXIF_TAG_PRIMARY_CHROMATICITIES:
+    return "@primary_chromaticities";
+    break;
+  case EXIF_TAG_SUB_IFDS:
+    return "@sub_ifds";
+    break;
+  case EXIF_TAG_TRANSFER_RANGE:
+    return "@transfer_range";
+    break;
+  case EXIF_TAG_JPEG_PROC:
+    return "@jpeg_proc";
+    break;
+  case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
+    return "@jpeg_interchange_format";
+    break;
+  case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
+    return "@jpeg_interchange_format_length";
+    break;
+  case EXIF_TAG_YCBCR_COEFFICIENTS:
+    return "@ycbcr_coefficients";
+    break;
+  case EXIF_TAG_YCBCR_SUB_SAMPLING:
+    return "@ycbcr_sub_sampling";
+    break;
+  case EXIF_TAG_YCBCR_POSITIONING:
+    return "@ycbcr_positioning";
+    break;
+  case EXIF_TAG_REFERENCE_BLACK_WHITE:
+    return "@reference_black_white";
+    break;
+  case EXIF_TAG_XML_PACKET:
+    return "@xml_packet";
+    break;
+  case EXIF_TAG_RELATED_IMAGE_FILE_FORMAT:
+    return "@related_image_file_format";
+    break;
+  case EXIF_TAG_RELATED_IMAGE_WIDTH:
+    return "@related_image_width";
+    break;
+  case EXIF_TAG_RELATED_IMAGE_LENGTH:
+    return "@related_image_length";
+    break;
+  case EXIF_TAG_CFA_REPEAT_PATTERN_DIM:
+    return "@cfa_repeat_pattern_dim";
+    break;
+  case EXIF_TAG_CFA_PATTERN:
+    return "@cfa_pattern";
+    break;
+  case EXIF_TAG_BATTERY_LEVEL:
+    return "@battery_level";
+    break;
+  case EXIF_TAG_COPYRIGHT:
+    return "@copyright";
+    break;
+  case EXIF_TAG_EXPOSURE_TIME:
+    return "@exposure_time";
+    break;
+  case EXIF_TAG_FNUMBER:
+    return "@fnumber";
+    break;
+  case EXIF_TAG_IPTC_NAA:
+    return "@iptc_naa";
+    break;
+  case EXIF_TAG_IMAGE_RESOURCES:
+    return "@image_resources";
+    break;
+  case EXIF_TAG_EXIF_IFD_POINTER:
+    return "@exif_ifd_pointer";
+    break;
+  case EXIF_TAG_INTER_COLOR_PROFILE:
+    return "@inter_color_profile";
+    break;
+  case EXIF_TAG_EXPOSURE_PROGRAM:
+    return "@exposure_program";
+    break;
+  case EXIF_TAG_SPECTRAL_SENSITIVITY:
+    return "@spectral_sensitivity";
+    break;
+  case EXIF_TAG_GPS_INFO_IFD_POINTER:
+    return "@gps_info_ifd_pointer";
+    break;
+  case EXIF_TAG_ISO_SPEED_RATINGS:
+    return "@iso_speed_ratings";
+    break;
+  case EXIF_TAG_OECF:
+    return "@oecf";
+    break;
+  case EXIF_TAG_TIME_ZONE_OFFSET:
+    return "@time_zone_offset";
+    break;
+  case EXIF_TAG_EXIF_VERSION:
+    return "@exif_version";
+    break;
+  case EXIF_TAG_DATE_TIME_ORIGINAL:
+    return "@date_time_original";
+    break;
+  case EXIF_TAG_DATE_TIME_DIGITIZED:
+    return "@date_time_digitized";
+    break;
+  case EXIF_TAG_COMPONENTS_CONFIGURATION:
+    return "@components_configuration";
+    break;
+  case EXIF_TAG_COMPRESSED_BITS_PER_PIXEL:
+    return "@compressed_bits_per_pixel";
+    break;
+  case EXIF_TAG_SHUTTER_SPEED_VALUE:
+    return "@shutter_speed_value";
+    break;
+  case EXIF_TAG_APERTURE_VALUE:
+    return "@aperture_value";
+    break;
+  case EXIF_TAG_BRIGHTNESS_VALUE:
+    return "@brightness_value";
+    break;
+  case EXIF_TAG_EXPOSURE_BIAS_VALUE:
+    return "@exposure_bias_value";
+    break;
+  case EXIF_TAG_MAX_APERTURE_VALUE:
+    return "@max_aperture_value";
+    break;
+  case EXIF_TAG_SUBJECT_DISTANCE:
+    return "@subject_distance";
+    break;
+  case EXIF_TAG_METERING_MODE:
+    return "@metering_mode";
+    break;
+  case EXIF_TAG_LIGHT_SOURCE:
+    return "@light_source";
+    break;
+  case EXIF_TAG_FLASH:
+    return "@flash";
+    break;
+  case EXIF_TAG_FOCAL_LENGTH:
+    return "@focal_length";
+    break;
+  case EXIF_TAG_SUBJECT_AREA:
+    return "@subject_area";
+    break;
+  case EXIF_TAG_TIFF_EP_STANDARD_ID:
+    return "@tiff_ep_standard_id";
+    break;
+  case EXIF_TAG_MAKER_NOTE:
+    return "@maker_note";
+    break;
+  case EXIF_TAG_USER_COMMENT:
+    return "@user_comment";
+    break;
+  case EXIF_TAG_SUB_SEC_TIME:
+    return "@sub_sec_time";
+    break;
+  case EXIF_TAG_SUB_SEC_TIME_ORIGINAL:
+    return "@sub_sec_time_original";
+    break;
+  case EXIF_TAG_SUB_SEC_TIME_DIGITIZED:
+    return "@sub_sec_time_digitized";
+    break;
+  case EXIF_TAG_XP_TITLE:
+    return "@xp_title";
+    break;
+  case EXIF_TAG_XP_COMMENT:
+    return "@xp_comment";
+    break;
+  case EXIF_TAG_XP_AUTHOR:
+    return "@xp_author";
+    break;
+  case EXIF_TAG_XP_KEYWORDS:
+    return "@xp_keywords";
+    break;
+  case EXIF_TAG_XP_SUBJECT:
+    return "@xp_subject";
+    break;
+  case EXIF_TAG_FLASH_PIX_VERSION:
+    return "@flash_pix_version";
+    break;
+  case EXIF_TAG_COLOR_SPACE:
+    return "@color_space";
+    break;
+  case EXIF_TAG_PIXEL_X_DIMENSION:
+    return "@pixel_x_dimension";
+    break;
+  case EXIF_TAG_PIXEL_Y_DIMENSION:
+    return "@pixel_y_dimension";
+    break;
+  case EXIF_TAG_RELATED_SOUND_FILE:
+    return "@related_sound_file";
+    break;
+  case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
+    return "@interoperability_ifd_pointer";
+    break;
+  case EXIF_TAG_FLASH_ENERGY:
+    return "@flash_energy";
+    break;
+  case EXIF_TAG_SPATIAL_FREQUENCY_RESPONSE:
+    return "@spatial_frequency_response";
+    break;
+  case EXIF_TAG_FOCAL_PLANE_X_RESOLUTION:
+    return "@focal_plane_x_resolution";
+    break;
+  case EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION:
+    return "@focal_plane_y_resolution";
+    break;
+  case EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT:
+    return "@focal_plane_resolution_unit";
+    break;
+  case EXIF_TAG_SUBJECT_LOCATION:
+    return "@subject_location";
+    break;
+  case EXIF_TAG_EXPOSURE_INDEX:
+    return "@exposure_index";
+    break;
+  case EXIF_TAG_SENSING_METHOD:
+    return "@sensing_method";
+    break;
+  case EXIF_TAG_FILE_SOURCE:
+    return "@file_source";
+    break;
+  case EXIF_TAG_SCENE_TYPE:
+    return "@scene_type";
+    break;
+  case EXIF_TAG_NEW_CFA_PATTERN:
+    return "@new_cfa_pattern";
+    break;
+  case EXIF_TAG_CUSTOM_RENDERED:
+    return "@custom_rendered";
+    break;
+  case EXIF_TAG_EXPOSURE_MODE:
+    return "@exposure_mode";
+    break;
+  case EXIF_TAG_WHITE_BALANCE:
+    return "@white_balance";
+    break;
+  case EXIF_TAG_DIGITAL_ZOOM_RATIO:
+    return "@digital_zoom_ratio";
+    break;
+  case EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM:
+    return "@focal_length_in_35mm_film";
+    break;
+  case EXIF_TAG_SCENE_CAPTURE_TYPE:
+    return "@scene_capture_type";
+    break;
+  case EXIF_TAG_GAIN_CONTROL:
+    return "@gain_control";
+    break;
+  case EXIF_TAG_CONTRAST:
+    return "@contrast";
+    break;
+  case EXIF_TAG_SATURATION:
+    return "@saturation";
+    break;
+  case EXIF_TAG_SHARPNESS:
+    return "@sharpness";
+    break;
+  case EXIF_TAG_DEVICE_SETTING_DESCRIPTION:
+    return "@device_setting_description";
+    break;
+  case EXIF_TAG_SUBJECT_DISTANCE_RANGE:
+    return "@subject_distance_range";
+    break;
+  case EXIF_TAG_IMAGE_UNIQUE_ID:
+    return "@image_unique_id";
+    break;
+  case EXIF_TAG_GAMMA:
+    return "@gamma";
+    break;
+  case EXIF_TAG_PRINT_IMAGE_MATCHING:
+    return "@print_image_matching";
+    break;
+  case EXIF_TAG_PADDING:
+    return "@padding";
+    break;
+  case EXIF_TAG_GPS_VERSION_ID:
+    return "@gps_version_id";
+    break;
+  case EXIF_TAG_GPS_LONGITUDE_REF:
+    return "@gps_longitude_ref";
+    break;
+  case EXIF_TAG_GPS_LONGITUDE:
+    return "@gps_longitude";
+    break;
+  case EXIF_TAG_GPS_ALTITUDE_REF:
+    return "@gps_altitude_ref";
+    break;
+  case EXIF_TAG_GPS_ALTITUDE:
+    return "@gps_altitude";
+    break;
+  case EXIF_TAG_GPS_TIME_STAMP:
+    return "@gps_time_stamp";
+    break;
+  case EXIF_TAG_GPS_SATELLITES:
+    return "@gps_satellites";
+    break;
+  case EXIF_TAG_GPS_STATUS:
+    return "@gps_status";
+    break;
+  case EXIF_TAG_GPS_MEASURE_MODE:
+    return "@gps_measure_mode";
+    break;
+  case EXIF_TAG_GPS_DOP:
+    return "@gps_dop";
+    break;
+  case EXIF_TAG_GPS_SPEED_REF:
+    return "@gps_speed_ref";
+    break;
+  case EXIF_TAG_GPS_SPEED:
+    return "@gps_speed";
+    break;
+  case EXIF_TAG_GPS_TRACK_REF:
+    return "@gps_track_ref";
+    break;
+  case EXIF_TAG_GPS_TRACK:
+    return "@gps_track";
+    break;
+  case EXIF_TAG_GPS_IMG_DIRECTION_REF:
+    return "@gps_img_direction_ref";
+    break;
+  case EXIF_TAG_GPS_IMG_DIRECTION:
+    return "@gps_img_direction";
+    break;
+  case EXIF_TAG_GPS_MAP_DATUM:
+    return "@gps_map_datum";
+    break;
+  case EXIF_TAG_GPS_DEST_LATITUDE_REF:
+    return "@gps_dest_latitude_ref";
+    break;
+  case EXIF_TAG_GPS_DEST_LATITUDE:
+    return "@gps_dest_latitude";
+    break;
+  case EXIF_TAG_GPS_DEST_LONGITUDE_REF:
+    return "@gps_dest_longitude_ref";
+    break;
+  case EXIF_TAG_GPS_DEST_LONGITUDE:
+    return "@gps_dest_longitude";
+    break;
+  case EXIF_TAG_GPS_DEST_BEARING_REF:
+    return "@gps_dest_bearing_ref";
+    break;
+  case EXIF_TAG_GPS_DEST_BEARING:
+    return "@gps_dest_bearing";
+    break;
+  case EXIF_TAG_GPS_DEST_DISTANCE_REF:
+    return "@gps_dest_distance_ref";
+    break;
+  case EXIF_TAG_GPS_DEST_DISTANCE:
+    return "@gps_dest_distance";
+    break;
+  case EXIF_TAG_GPS_PROCESSING_METHOD:
+    return "@gps_processing_method";
+    break;
+  case EXIF_TAG_GPS_AREA_INFORMATION:
+    return "@gps_area_information";
+    break;
+  case EXIF_TAG_GPS_DATE_STAMP:
+    return "@gps_date_stamp";
+    break;
+  case EXIF_TAG_GPS_DIFFERENTIAL:
+    return "@gps_differential";
+    break;
+  }
+  return 0;
+}

data/ext/exif/extconf.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+$CFLAGS << ' -std=c99 '
+have_library('exif')
+have_header('libexif/exif-data.h')
+create_makefile('exif/exif')

data/lib/exif.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'exif/version'
+require 'exif/exif'
+
+module Exif
+
+	class Data
+
+		def latitude
+			hemi = self.gps_latitude_ref == "N" ? 1 : -1
+			lat_f = (self.gps_latitude[0].to_f+self.gps_latitude[1].to_f/60.0+self.gps_latitude[2].to_f/3600.0)*hemi
+			return lat_f
+		end
+
+		def longitude
+			hemi = self.gps_longitude_ref == "E" ? 1 : -1
+			lng_f = (self.gps_longitude[0].to_f+self.gps_longitude[1].to_f/60.0+self.gps_longitude[2].to_f/3600.0)*hemi
+			return lng_f
+		end
+
+		def altitude
+			return gps_altitude.to_f
+		end
+
+	end
+
+end

data/lib/exif/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Exif
+  VERSION = '2.0.1'
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: exif-aerial
+version: !ruby/object:Gem::Version
+  version: 2.0.1
+platform: ruby
+authors:
+- Jian Weihang
+- Nathan Sullivan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.0.0
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.10.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.10.3
+description: Adds latitude, longitude, altitude accessors.
+email: nathan@aerialapplications.com
+executables: []
+extensions:
+- ext/exif/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/exif/data.c
+- ext/exif/data.h
+- ext/exif/exif.c
+- ext/exif/exif_entry_to_ivar.c
+- ext/exif/extconf.rb
+- lib/exif.rb
+- lib/exif/version.rb
+homepage: https://github.com/tonytonyjan/exif
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Ruby EXIF reader written in C extension.
+test_files: []