Merge branch 'Feat/metadata' into 'dev'

Feat/metadata

See merge request !114

javadoc/allclasses.html

@@ -38,7 +38,7 @@
 <li><a href="NTNU/IDATT1002/models/GeoLocation.html" title="class in NTNU.IDATT1002.models">GeoLocation</a></li>
 <li><a href="NTNU/IDATT1002/repository/GeoLocatioRepository.html" title="class in NTNU.IDATT1002.repository">GeoLocatioRepository</a></li>
 <li><a href="NTNU/IDATT1002/models/Histogram.html" title="class in NTNU.IDATT1002.models">Histogram</a></li>
-<li><a href="NTNU/IDATT1002/repository/HistorgramRepository.html" title="class in NTNU.IDATT1002.repository">HistorgramRepository</a></li>
+<li><a href="NTNU/IDATT1002/repository/Repository.html" title="class in NTNU.IDATT1002.repository">HistorgramRepository</a></li>
 <li><a href="NTNU/IDATT1002/models/Image.html" title="class in NTNU.IDATT1002.models">Image</a></li>
 <li><a href="NTNU/IDATT1002/filters/ImageFilter.html" title="class in NTNU.IDATT1002.filters">ImageFilter</a></li>
 <li><a href="NTNU/IDATT1002/repository/ImageRepository.html" title="class in NTNU.IDATT1002.repository">ImageRepository</a></li>

src/main/java/NTNU/IDATT1002/models/Histogram.java

-package NTNU.IDATT1002.models;
-
-
-import javax.persistence.*;
-import javax.validation.constraints.NotBlank;
-
-/**
- * Creates histogram table
- */
-
-@Entity
-@Table(name = "histogram")
-public class Histogram {
-
-    /**
-     * Defines id, may not be blank
-     */
-    @Id
-    @GeneratedValue
-    private Long histogramId;
-
-    /**
-     * One to one relations, joins histogramId
-     * On columns histogramId in metadata
-     */
-    @OneToOne(mappedBy = "histogram", fetch = FetchType.LAZY)
-    private Metadata metadata;
-
-    @Lob
-    @NotBlank(message = "Data may not be blank")
-    private String data;
-
-    public Histogram() {
-    }
-
-    public Long getHistogramId() {
-        return histogramId;
-    }
-
-    public String getData() {
-        return data;
-    }
-
-    public void setHistogramId(Long histogramId) {
-        this.histogramId = histogramId;
-    }
-
-    public void setData(String data) {
-        this.data = data;
-    }
-
-    public void setMetadata(Metadata metadata) {
-        this.metadata = metadata;
-    }
-
-    @Override
-    public String toString() {
-        return "Histogram{" +
-                "histogramId=" + histogramId +
-                ", data='" + data + '\'' +
-                '}';
-    }
-}

src/main/java/NTNU/IDATT1002/models/Metadata.java

@@ -28,17 +28,39 @@ public class Metadata {
     @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
     private GeoLocation geolocation;
 
-    @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
-    private Histogram histogram;
+    @Column(name = "camera")
+    private String camera;
+
+    @Column(name = "lens")
+    private String lens;
+
+    @Column(name = "aperture")
+    private String aperture;
+
+    @Column(name = "shutterspeed")
+    private String shutterSpeed;
+
+    @Column(name = "iso")
+    private String ISO;
+
+    @Column(name = "focallength")
+    private String focalLength;
+
+    @Column(name = "filetype")
+    private String fileType;
+
+    @Column(name = "photodate")
+    private String photoDate;
+
+    @Column(name = "filesize")
+    private String fileSize;
+
+    @Column(name = "filedimension")
+    private String fileDimension;
 
     public Metadata() {
     }
 
-    public Metadata(Image image, GeoLocation geoLocation, Histogram histogram) {
-        this.image = image;
-        this.geolocation = geolocation;
-        this.histogram = histogram;
-    }
 
     public Long getMetadataId() {
         return metadataId;
@@ -52,8 +74,20 @@ public class Metadata {
         return geolocation;
     }
 
-    public Histogram getHistogram() {
-        return histogram;
+    public String getCamera() {
+        return camera;
+    }
+
+    public void setCamera(String camera) {
+        this.camera = camera;
+    }
+
+    public String getLens() {
+        return lens;
+    }
+
+    public void setLens(String lens) {
+        this.lens = lens;
     }
 
     public void setImage(Image image) {
@@ -64,16 +98,84 @@ public class Metadata {
         this.geolocation = geolocation;
     }
 
-    public void setHistogram(Histogram histogram) {
-        this.histogram = histogram;
+    public String getAperture() {
+        return aperture;
+    }
+
+    public String getShutterSpeed() {
+        return shutterSpeed;
+    }
+
+    public String getISO() {
+        return ISO;
+    }
+
+    public String getFocalLength() {
+        return focalLength;
+    }
+
+    public String getFileType() {
+        return fileType;
+    }
+
+    public String getPhotoDate() {
+        return photoDate;
+    }
+
+    public String getFileSize() {
+        return fileSize;
+    }
+
+    public String getFileDimension() {
+        return fileDimension;
+    }
+
+    public void setAperture(String aperture) {
+        this.aperture = aperture;
+    }
+
+    public void setShutterSpeed(String shutterSpeed) {
+        this.shutterSpeed = shutterSpeed;
+    }
+
+    public void setISO(String ISO) {
+        this.ISO = ISO;
+    }
+
+    public void setFocalLength(String focalLength) {
+        this.focalLength = focalLength;
+    }
+
+    public void setFileType(String fileType) {
+        this.fileType = fileType;
+    }
+
+    public void setPhotoDate(String photoDate) {
+        this.photoDate = photoDate;
+    }
+
+    public void setFileSize(String fileSize) {
+        this.fileSize = fileSize;
+    }
+
+    public void setFileDimension(String fileDimension) {
+        this.fileDimension = fileDimension;
     }
 
     @Override
     public String toString() {
         return "Metadata{" +
-                "metadataId=" + metadataId +
-                ", geolocation=" + geolocation +
-                ", histogram=" + histogram +
-                '}';
+            "metadataId=" + metadataId +
+            ", camera='" + camera + '\'' +
+            ", lens='" + lens + '\'' +
+            ", aperture='" + aperture + '\'' +
+            ", shutterSpeed='" + shutterSpeed + '\'' +
+            ", ISO='" + ISO + '\'' +
+            ", focalLength='" + focalLength + '\'' +
+            ", fileType='" + fileType + '\'' +
+            ", photoDate='" + photoDate + '\'' +
+            ", fileSize='" + fileSize + '\'' +
+            ", fileDimension='" + fileDimension + '\'' +
+            '}';
     }
 }

src/main/java/NTNU/IDATT1002/repository/HistorgramRepository.java

-package NTNU.IDATT1002.repository;
-
-import NTNU.IDATT1002.models.Histogram;
-
-import javax.persistence.EntityManager;
-
-public class HistorgramRepository extends AbstractRepository<Histogram, Long> {
-
-    /**
-     * Constructor to inject {@link EntityManager} dependency.
-     *
-     * @param entityManager the entity manager to utilize
-     */
-    public HistorgramRepository(EntityManager entityManager) {
-        super(entityManager);
-        setEntityClass(Histogram.class);
-    }
-}

src/main/java/NTNU/IDATT1002/service/ImageService.java

@@ -45,7 +45,6 @@ public class ImageService {
     public Optional<Image> createImage(User user, File file, List<Tag> tags) {
 
         GeoLocation geoLocation = metaDataExtractor.getGeoLocation(file);
-        Histogram histogram = metaDataExtractor.getHistogram(file);
 
         Image image = new Image();
         Metadata metadata = new Metadata();
@@ -55,8 +54,7 @@ public class ImageService {
         metadata.setGeoLocation(geoLocation);
         geoLocation.setMetadata(metadata);
 
-        metadata.setHistogram(histogram);
-        histogram.setMetadata(metadata);
+        metaDataExtractor.setMetadata(metadata, file);
         byte[] bFile = ImageUtil.convertToBytes(file.getPath());
 
         //TODO: Add image tags and add image to album

src/main/java/NTNU/IDATT1002/utils/MetaDataExtractor.java

@@ -2,15 +2,21 @@ package NTNU.IDATT1002.utils;
 
 import NTNU.IDATT1002.database.EntityManagerConfig;
 import NTNU.IDATT1002.models.GeoLocation;
-import NTNU.IDATT1002.models.Histogram;
 import NTNU.IDATT1002.repository.GeoLocatioRepository;
-import NTNU.IDATT1002.repository.HistorgramRepository;
 import com.drew.imaging.ImageMetadataReader;
 import com.drew.imaging.ImageProcessingException;
+import com.drew.metadata.Directory;
 import com.drew.metadata.Metadata;
-import com.drew.metadata.MetadataException;
+import com.drew.metadata.Tag;
+import com.drew.metadata.exif.ExifIFD0Directory;
+import com.drew.metadata.exif.ExifSubIFDDirectory;
 import com.drew.metadata.exif.GpsDirectory;
 
+import com.drew.metadata.file.FileSystemDirectory;
+import com.drew.metadata.file.FileTypeDirectory;
+import com.drew.metadata.iptc.IptcDirectory;
+
+import com.drew.metadata.jpeg.JpegDirectory;
 import javax.persistence.EntityManager;
 import java.io.File;
 import java.io.IOException;
@@ -22,22 +28,13 @@ import java.io.IOException;
 public class MetaDataExtractor {
 
     private GeoLocatioRepository geoLocationRepository;
-    private HistorgramRepository historgramRepository;
 
     public MetaDataExtractor() {
-        EntityManager entityManager = EntityManagerConfig.getEntityManager();
-
-        this.historgramRepository = new HistorgramRepository(entityManager);
-        this.geoLocationRepository = new GeoLocatioRepository(entityManager);
     }
 
     /**
      * Returns a string with the GPS position
-     *
-     * @return
-     * @throws ImageProcessingException
-     * @throws IOException
-     * @throws MetadataException
+     * @return the gelocation of the file
      */
     public GeoLocation getGeoLocation(File file) {
         String gps = "";
@@ -64,34 +61,292 @@ public class MetaDataExtractor {
     }
 
     /**
-     * TODO: Decide what data to store.
-     *
-     * @param file
-     * @return
+     * Gets the camera Make and Model of the camera used to take the photo
+     * @param file that will be checked for Camera make
+     * @return empty string if nothings found
+     */
+    public String getCamera(File file) {
+        String cameraInformation = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(ExifIFD0Directory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("Make") || tag.toString().contains("Model")) {
+                    cameraInformation += tag.toString() + ",";
+                }
+            }
+            if(!(cameraInformation.isBlank()))
+                cameraInformation = cleanUpTags(cameraInformation, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return cameraInformation;
+    }
+
+    /**
+     * Method for getting lens iformation
+     * @param file that will be checked
+     * @return empty string if nothing is found
      */
-    public Histogram getHistogram(File file) {
-//        Metadata metadata = null;
-//
-//        try {
-//            metadata = ImageMetadataReader.readMetadata(file);
-//        } catch (IOException | ImageProcessingException e) {
-//            e.printStackTrace();
-//        }
-//
-//        StringBuilder data = new StringBuilder();
-//        assert metadata != null;
-//        for(Directory d : metadata.getDirectories()) {
-//            for (Tag t : d.getTags()) {
-//                data.append(t.toString()).append(" | ");
-//            }
-//        }
-//        histogram.setData(data.toString());
-
-
-        Histogram histogram = new Histogram();
-        histogram.setData("INSERT DATA HERE");
-
-        return histogram;
+    public String getLens(File file) {
+        String lensInformation = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(ExifSubIFDDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("Lens")) {
+                    lensInformation += tag.toString() + ",";
+                }
+            }
+            if(!(lensInformation.isBlank()))
+                lensInformation = cleanUpTags(lensInformation, directory);
+        }
+        catch (IOException | ImageProcessingException | NullPointerException e) {
+        e.printStackTrace();
+        }
+        return lensInformation;
     }
 
+    /**
+     * Method for getting aperture information
+     * @param file that will be checked
+     * @return empty string if nothing is found
+     */
+    public String getAperture(File file) {
+        String apertureInformation = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(ExifSubIFDDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("Aperture")) {
+                    apertureInformation += tag.toString() + ",";
+                }
+            }
+            if(!(apertureInformation.isBlank()))
+                apertureInformation = cleanUpTags(apertureInformation, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return apertureInformation;
+    }
+
+    /**
+     * Method for getting shutterspeed information
+     * @param file that will be checked
+     * @return empty string if nothing is found
+     */
+    public String getShutterSpeed(File file) {
+        String shutterSpeedInformation = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(ExifSubIFDDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("Shutter")) {
+                    shutterSpeedInformation += tag.toString() + ",";
+                }
+            }
+            if(!(shutterSpeedInformation.isBlank()))
+                shutterSpeedInformation = cleanUpTags(shutterSpeedInformation, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return shutterSpeedInformation;
+    }
+
+    /**
+     * Method for getting iso information
+     * @param file that will be checked
+     * @return empty string if nothing is found
+     */
+    public String getIso(File file) {
+        String isoInformation = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(ExifSubIFDDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("ISO")) {
+                    isoInformation += tag.toString() + ",";
+                }
+            }
+            if(!(isoInformation.isBlank()))
+                isoInformation = cleanUpTags(isoInformation, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return isoInformation;
+    }
+
+    /**
+     * Method for getting focal length information
+     * @param file that will be checked
+     * @return empty string if nothing is found
+     */
+    public String getFocalLength(File file) {
+        String focalLengthInformation = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(ExifSubIFDDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("Focal Length")) {
+                    focalLengthInformation += tag.toString() + ",";
+                    break;
+                }
+            }
+            if(!(focalLengthInformation.isBlank()))
+                focalLengthInformation = cleanUpTags(focalLengthInformation, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return focalLengthInformation;
+    }
+
+    /**
+     * Method for getting file type information
+     * @param file that will be checked
+     * @return empty string if nothing is found
+     */
+    public String getFileType(File file) {
+        String fileTypeInformation = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(FileTypeDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("File Type Name")) {
+                    fileTypeInformation += tag.toString() + ",";
+                    break;
+                }
+            }
+            if(!(fileTypeInformation.isBlank()))
+                fileTypeInformation = cleanUpTags(fileTypeInformation, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return fileTypeInformation;
+    }
+
+    /**
+     * Method for getting date information
+     * @param file that will be checked
+     * @return empty string if nothing is found
+     */
+    public String getPhotoDate(File file) {
+        String dateInformation = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(IptcDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("Date Created")) {
+                    dateInformation += tag.toString() + ",";
+                    break;
+                }
+            }
+            for(Tag tag : directory.getTags()) {
+               if(tag.toString().contains("Time Created")) {
+                   dateInformation += tag.toString() + ",";
+                   break;
+               }
+            }
+            if(!(dateInformation.isBlank()))
+                dateInformation = cleanUpTags(dateInformation, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return dateInformation;
+    }
+
+    /**
+     * Method for getting file size
+     * @param file that will be checked
+     * @return empty string if nothing is found
+     */
+    public String getFileSize(File file) {
+        String fileSize = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(FileSystemDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("Size")) {
+                    fileSize += tag.toString() + ",";
+                }
+            }
+            if(!(fileSize.isBlank()))
+                fileSize = cleanUpTags(fileSize, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return fileSize;
+    }
+
+
+    /**
+     * Method for getting file dimension
+     * @param file that will be checked
+     * @return empty string if nothing is found
+     */
+    public String getFileDimension(File file) {
+        String fileDimension = "";
+        Directory directory;
+
+        try {
+            Metadata metadata = ImageMetadataReader.readMetadata(file);
+            directory = metadata.getFirstDirectoryOfType(JpegDirectory.class);
+            for(Tag tag : directory.getTags()) {
+                if(tag.toString().contains("Height") || tag.toString().contains("Width")) {
+                    fileDimension += tag.toString() + ",";
+                }
+            }
+            if(!(fileDimension.isBlank()))
+                fileDimension = cleanUpTags(fileDimension, directory);
+        } catch (IOException | ImageProcessingException | NullPointerException e) {
+            e.printStackTrace();
+        }
+        return fileDimension;
+    }
+    
+    public void setMetadata(NTNU.IDATT1002.models.Metadata metadata, File file) {
+        metadata.setCamera(getCamera(file));
+        metadata.setLens(getLens(file));
+        metadata.setAperture(getAperture(file));
+        metadata.setShutterSpeed(getShutterSpeed(file));
+        //metadata.setISO(getIso(file));
+        metadata.setFocalLength(getFocalLength(file));
+        metadata.setFileType(getFileType(file));
+        metadata.setPhotoDate(getPhotoDate(file));
+        metadata.setFileSize(getFileSize(file));
+        metadata.setFileDimension(getFileDimension(file));
+    }
+
+    /**
+     * Cleans up the tags on a string
+     * @param textToClean string that will be cleaned
+     * @param directoryToRemove directory that will be removed from string
+     * @return cleaned string
+     */
+    private String cleanUpTags(String textToClean, Directory directoryToRemove) {
+        String removingText = directoryToRemove.getName();
+        textToClean = textToClean.replace(removingText, "");
+        textToClean = textToClean.replace("[", "");
+        textToClean = textToClean.replace("]", "");
+        textToClean = textToClean.replace(" - ", ": ");
+        textToClean = textToClean.substring(0, textToClean.length()-1);
+        return textToClean;
+    }
 }

src/main/resources/META-INF/persistence.xml

@@ -14,7 +14,6 @@
         <class>NTNU.IDATT1002.models.Album</class>
         <class>NTNU.IDATT1002.models.Tag</class>
         <class>NTNU.IDATT1002.models.Metadata</class>
-        <class>NTNU.IDATT1002.models.Histogram</class>
         <class>NTNU.IDATT1002.models.GeoLocation</class>
 
         <properties>