Some Structure changes

This commit is contained in:
RobinFleige committed 2018-08-16 08:46:39 +02:00
1 parent efe06e84f3
commit cc66e99e8a
3 files changed
+160 -139

No files matched your search

@@ -7891,43 +7891,25 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
@Override
public ImageDTO[] resizeImage(ToResizeImageDTO toResizeImage) throws Exception {
// In following size tag will describe the tags, that have a defined size in MediaConstants, which is LOGO,
// TEASER and STAGE at the moment
//create ArrayList that will contain all images that are to return
List<ImageDTO> resizedImages = new ArrayList<ImageDTO>();
// calculating the fileType of the image by its uri
String fileType = toResizeImage.getSourceRef().substring(toResizeImage.getSourceRef().lastIndexOf(".")+1);
// splitting the size-tags in size-tags that need a resize and size-tags that do not need a resize
List<String> resizeTags = new ArrayList<>();
List<String> notResizeSizeTags = new ArrayList<>();
//Create ImageConverter for further use
ImageConverter converter = new ImageConverter(getService().getFileStorageManagementService().getActiveFileStorageService()
.loadFile(new URI(toResizeImage.getSourceRef())), fileType);
converter.splitSizeTags(toResizeImage.getMap(), resizeTags, notResizeSizeTags);
// deleting all size-tags from the tags list, because after resizing there should only be one size tag per image
toResizeImage.getTags().removeAll(toResizeImage.getMap().keySet());
// iterating over every size-tag that needs a resize
for (String resizeTag : resizeTags) {
// creating a new ImageDTO object with all values from the ToResizeImageDTO object
ImageDTO image = toImageDTO(toResizeImage);
// re-adding the size-tag for this iteration, so every ImageDTO object only has one size-tag
image.getTags().add(resizeTag);
// resizing the image
BufferedImage resizedBufferedImage = resizeImage(converter, resizeTag, fileType);
// adding the new width and h eight to the ImageDTO object
image.setSizeInPx(resizedBufferedImage.getWidth(), resizedBufferedImage.getHeight());
// storing the image on FileStorageService
InputStream fileStorageStream = converter.resizedImageToInputStream(resizedBufferedImage);
URI newUri = getService().getFileStorageManagementService().getActiveFileStorageService().storeFile(fileStorageStream,
"." + fileType, new Long(fileStorageStream.available()));
// saving the new image ref uri to the ImageDTO object
image.setSourceRef(newUri.toString());
// adding the resized ImageDTO object to arraylist
resizedImages.add(image);
}
// if there is no size tag that does not need a resize we can delete the original source
if (notResizeSizeTags.isEmpty()) {
//Create ImageConverter for further use
ImageConverter converter = new ImageConverter(getService().getFileStorageManagementService().getActiveFileStorageService()
.loadFile(new URI(toResizeImage.getSourceRef())), fileType, toResizeImage.getMap());
addImagesThatNeedResizing(converter, resizedImages, toResizeImage);
addImagesThatDoNotNeedResizing(converter, resizedImages, toResizeImage);
return resizedImages.toArray(new ImageDTO[resizedImages.size()]);
}
private void addImagesThatDoNotNeedResizing(ImageConverter converter, List<ImageDTO> resizedImages, ToResizeImageDTO toResizeImage) {
// if there is no size tag that does not need a resize we can delete the original source
if (converter.getNotResizeSizeTags().isEmpty()) {
try {
getService().getFileStorageManagementService().getActiveFileStorageService()
.removeFile(new URI(toResizeImage.getSourceRef()));
@@ -7940,17 +7922,38 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
}
} else {
// otherwise we have to create an ImageDTO object for every non-resize-size-tag
for (String resizeTag : notResizeSizeTags) {
for (String resizeTag : converter.getNotResizeSizeTags()) {
ImageDTO image = toImageDTO(toResizeImage);
// re-add the deleted specific size tag
image.getTags().add(resizeTag);
resizedImages.add(image);
}
}
return resizedImages.toArray(new ImageDTO[resizedImages.size()]);
}
private BufferedImage resizeImage(ImageConverter converter, String resizeTag, String fileType) {
private void addImagesThatNeedResizing(ImageConverter converter, List<ImageDTO> resizedImages, ToResizeImageDTO toResizeImage) throws Exception{
// iterating over every size-tag that needs a resize
for (String resizeTag : converter.getResizeTags()) {
// creating a new ImageDTO object with all values from the ToResizeImageDTO object
ImageDTO image = toImageDTO(toResizeImage);
// re-adding the size-tag for this iteration, so every ImageDTO object only has one size-tag
image.getTags().add(resizeTag);
// resizing the image
BufferedImage resizedBufferedImage = resizeImage(converter, resizeTag);
// adding the new width and h eight to the ImageDTO object
image.setSizeInPx(resizedBufferedImage.getWidth(), resizedBufferedImage.getHeight());
// storing the image on FileStorageService
InputStream fileStorageStream = converter.resizedImageToInputStream(resizedBufferedImage);
URI newUri = getService().getFileStorageManagementService().getActiveFileStorageService().storeFile(fileStorageStream,
"." + converter.getImageFormat(), new Long(fileStorageStream.available()));
// saving the new image ref uri to the ImageDTO object
image.setSourceRef(newUri.toString());
// adding the resized ImageDTO object to arraylist
resizedImages.add(image);
}
}
private BufferedImage resizeImage(ImageConverter converter, String resizeTag) {
BufferedImage resizedImage = null;
switch (resizeTag) {
case MediaTagConstants.LOGO:
@@ -7976,7 +7979,7 @@ public class SailingServiceImpl extends ProxiedRemoteServiceServlet implements S
return resizedImage;
}
public ImageDTO toImageDTO(ToResizeImageDTO toResizeImage) {
private ImageDTO toImageDTO(ToResizeImageDTO toResizeImage) {
ImageDTO toReturn = new ImageDTO(toResizeImage.getSourceRef(), toResizeImage.getCreatedAtDate());
toReturn.setTitle(toResizeImage.getTitle());
toReturn.setCopyright(toResizeImage.getCopyright());
@@ -7,6 +7,7 @@ import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.util.HashMap;
import org.junit.Before;
import org.junit.Test;
@@ -27,8 +28,8 @@ public class ImageConverterTest {
@Before
public void setUp() {
jpgConverter = new ImageConverter(new ByteArrayInputStream(onePixelJpgExample),"jpg");
pngConverter = new ImageConverter(new ByteArrayInputStream(onePixelPngExample),"png");
jpgConverter = new ImageConverter(new ByteArrayInputStream(onePixelJpgExample),"jpg", new HashMap<String, Boolean>());
pngConverter = new ImageConverter(new ByteArrayInputStream(onePixelPngExample),"png", new HashMap<String, Boolean>());
assertNotNull(jpgConverter.getImage());
assertNotNull(pngConverter.getImage());
}
@@ -8,6 +8,7 @@ import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Iterator;
import java.util.List;
@@ -25,18 +26,86 @@ import javax.imageio.stream.ImageOutputStream;
public class ImageConverter {
private BufferedImage image;
private final BufferedImage image;
private IIOMetadata metadata;
private final String imageFormat;
private final List<String> resizeTags;
private final List<String> notResizeSizeTags;
private static final Logger logger = Logger.getLogger(ImageConverter.class.getName());
public ImageConverter(InputStream is, String imageFormat) {
public ImageConverter(InputStream is, String imageFormat, Map<String,Boolean> sizeTags) {
this.imageFormat = imageFormat;
calculateImageAndMetadata(is);
this.image = calculateImageAndMetadata(is);
// splitting the size-tags in size-tags that need a resize and size-tags that do not need a resize
resizeTags = new ArrayList<>();
notResizeSizeTags = new ArrayList<>();
splitSizeTags(sizeTags, resizeTags, notResizeSizeTags);
}
private BufferedImage calculateImageAndMetadata(InputStream is) {
// trying to receive the EXIF data and loading the image. If this does not work only the image is loaded
BufferedImage image = null;
boolean loaded = false;
byte[] bytes = inputStreamToByteArray(is);
try {
Iterator<ImageReader> readerIterator = ImageIO.getImageReadersBySuffix(imageFormat);
while (readerIterator.hasNext() && !loaded) {
ImageReader reader = readerIterator.next();
reader.setInput(ImageIO.createImageInputStream(new ByteArrayInputStream(bytes)));
metadata = reader.getImageMetadata(0);
image = reader.read(0);
loaded = metadata != null;
}
if (!loaded) {
throw new Exception(
"Loading file via ImageReader did not work, not able to load metadata, retrying to load with ImageIO.read()");
}
} catch (Exception e) {
logger.log(Level.INFO, e.getMessage());
}
if (!loaded) {
image = loadBufferedImageFromInputStream(new ByteArrayInputStream(bytes));
}
try {
is.close();
} catch (IOException e) {
logger.log(Level.WARNING, "Potential ressource leak");
}
return image;
}
private void splitSizeTags(Map<String, Boolean> sizeTags, List<String> resizeTags, List<String> notResizeSizeTags) {
for (Object tagKey : sizeTags.keySet()) {
if (sizeTags.get(tagKey)) {
resizeTags.add((String) tagKey);// size tags, that have the resize checkBox checked
} else {
notResizeSizeTags.add((String) tagKey);// size tags, that not have the resize checkBox checked
}
}
}
public InputStream sourceImageToInputStream() {//public for testing
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
ImageIO.write(image, imageFormat, bos);
} catch (IOException e) {
logger.log(Level.SEVERE, e.getMessage());
}
byte[] arr = bos.toByteArray();
return new ByteArrayInputStream(arr);
}
public BufferedImage resize(int minWidth, int maxWidth, int minHeight, int maxHeight) {
int[] dimensions = calculateDimensions(image.getWidth(), image.getHeight(), minWidth, maxWidth, minHeight,
maxHeight);
if (dimensions != null) {
return resize(dimensions[0], dimensions[1]);
}
return null;
}
public static int[] calculateDimensions(double width, double height, double minWidth, double maxWidth,
double minHeight, double maxHeight) {
double minHeight, double maxHeight) {//Public for testing, static because it is completely independend
if (maxWidth >= 0 && maxHeight >= 0 && maxHeight > minHeight && maxWidth > minWidth && width > minWidth && height > minHeight) {
if (maxWidth <= width || maxHeight <= height) {
if (width / maxWidth > height / maxHeight) {
@@ -57,61 +126,10 @@ public class ImageConverter {
return null;
}
public BufferedImage resize(int demandWidth, int demandHeight) {
private BufferedImage resize(int demandWidth, int demandHeight) {
return resizeScale(demandWidth, demandHeight);
}
public BufferedImage resize(int minWidth, int maxWidth, int minHeight, int maxHeight) {
int[] dimensions = calculateDimensions(image.getWidth(), image.getHeight(), minWidth, maxWidth, minHeight,
maxHeight);
if (dimensions != null) {
return resize(dimensions[0], dimensions[1]);
}
return null;
}
public InputStream sourceImageToInputStream() {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
ImageIO.write(image, imageFormat, bos);
} catch (IOException e) {
logger.log(Level.SEVERE, e.getMessage());
}
byte[] arr = bos.toByteArray();
return new ByteArrayInputStream(arr);
}
public static String convertToBase64(InputStream is, String imageFormat) throws IOException {
return convertToBase64(bufferedImageToByteArray(loadBufferedImageFromInputStream(is), imageFormat));
}
public static String convertToBase64(BufferedImage img, String imageFormat) throws IOException {
return convertToBase64(bufferedImageToByteArray(img, imageFormat));
}
private static String convertToBase64(byte[] bytes) {
return Base64.getEncoder().encodeToString(bytes);
}
public static BufferedImage loadBufferedImageFromInputStream(InputStream is) {
try {
return ImageIO.read(is);
} catch (IOException e) {
logger.log(Level.SEVERE, e.getMessage());
}
return null;
}
public static byte[] bufferedImageToByteArray(BufferedImage img, String imageFormat) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
ImageIO.write(img, imageFormat, baos);
} catch (IOException e) {
logger.log(Level.SEVERE, e.getMessage());
}
return baos.toByteArray();
}
private BufferedImage resizeScale(int demandedWidth, int demandedHeight) {
BufferedImage resizedImage = new BufferedImage((int) demandedWidth, (int) demandedHeight, image.getType());
Graphics2D g = resizedImage.createGraphics();
@@ -120,17 +138,7 @@ public class ImageConverter {
return resizedImage;
}
public void splitSizeTags(Map<String, Boolean> sizeTags, List<String> resizeTags, List<String> notResizeSizeTags) {
for (Object tagKey : sizeTags.keySet()) {
if (sizeTags.get(tagKey)) {
resizeTags.add((String) tagKey);// size tags, that have the resize checkBox checked
} else {
notResizeSizeTags.add((String) tagKey);// size tags, that not have the resize checkBox checked
}
}
}
public InputStream resizedImageToInputStream(BufferedImage resizedBufferedImage) throws Exception {
public InputStream resizedImageToInputStream(BufferedImage resizedBufferedImage) {
byte[] bytes = null;
// trying to obtain OutputStream of the image with EXIF data
try (ImageOutputStream ios = ImageIO.createImageOutputStream(new ByteArrayOutputStream())) {
@@ -171,17 +179,7 @@ public class ImageConverter {
return toReturn;
}
private boolean isZeroByteArray(byte[] bytes) {
boolean toReturn = true;
for (int i = 0; i < bytes.length; i++) {
if (bytes[i] != 0) {
toReturn = false;
}
}
return toReturn;
}
public byte[] inputStreamToByteArray(InputStream is) {
public byte[] inputStreamToByteArray(InputStream is) {//public for testing
byte[] byteArray = null;
try {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
@@ -198,34 +196,14 @@ public class ImageConverter {
return byteArray;
}
private void calculateImageAndMetadata(InputStream is) {
// trying to receive the EXIF data and loading the image. If this does not work only the image is loaded
boolean loaded = false;
byte[] bytes = inputStreamToByteArray(is);
try {
Iterator<ImageReader> readerIterator = ImageIO.getImageReadersBySuffix(imageFormat);
while (readerIterator.hasNext() && !loaded) {
ImageReader reader = readerIterator.next();
reader.setInput(ImageIO.createImageInputStream(new ByteArrayInputStream(bytes)));
metadata = reader.getImageMetadata(0);
image = reader.read(0);
loaded = metadata != null;
private boolean isZeroByteArray(byte[] bytes) {
boolean toReturn = true;
for (int i = 0; i < bytes.length; i++) {
if (bytes[i] != 0) {
toReturn = false;
}
if (!loaded) {
throw new Exception(
"Loading file via ImageReader did not work, not able to load metadata, retrying to load with ImageIO.read()");
}
} catch (Exception e) {
logger.log(Level.INFO, e.getMessage());
}
if (!loaded) {
image = loadBufferedImageFromInputStream(new ByteArrayInputStream(bytes));
}
try {
is.close();
} catch (IOException e) {
logger.log(Level.WARNING, "Potential ressource leak");
}
return toReturn;
}
public BufferedImage getImage() {
@@ -239,4 +217,43 @@ public class ImageConverter {
public String getImageFormat() {
return imageFormat;
}
public List<String> getResizeTags() {
return resizeTags;
}
public List<String> getNotResizeSizeTags() {
return notResizeSizeTags;
}
//these methods are static, so it is not necessary to create an ImageConverter object for the conversion to Base64
public static String convertToBase64(InputStream is, String imageFormat) throws IOException {
return convertToBase64(bufferedImageToByteArray(loadBufferedImageFromInputStream(is), imageFormat));
}
public static String convertToBase64(BufferedImage img, String imageFormat) throws IOException {
return convertToBase64(bufferedImageToByteArray(img, imageFormat));
}
private static String convertToBase64(byte[] bytes) {
return Base64.getEncoder().encodeToString(bytes);
}
private static BufferedImage loadBufferedImageFromInputStream(InputStream is) {
try {
return ImageIO.read(is);
} catch (IOException e) {
logger.log(Level.SEVERE, e.getMessage());
}
return null;
}
public static byte[] bufferedImageToByteArray(BufferedImage img, String imageFormat) {//public for testing
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
ImageIO.write(img, imageFormat, baos);
} catch (IOException e) {
logger.log(Level.SEVERE, e.getMessage());
}
return baos.toByteArray();
}
}