Качество изображения после изменения размера очень низкое - Java
В сценарии это происходит от отметки 300х300 до 60х60. Необходимо улучшить общее качество изображения, так как в данный момент оно выходит очень плохо.
public static Boolean resizeImage(String sourceImg, String destImg, Integer Width, Integer Height, Integer whiteSpaceAmount)
{
BufferedImage origImage;
try
{
origImage = ImageIO.read(new File(sourceImg));
int type = origImage.getType() == 0? BufferedImage.TYPE_INT_ARGB : origImage.getType();
int fHeight = Height;
int fWidth = Width;
int whiteSpace = Height + whiteSpaceAmount; //Formatting all to squares so don't need two whiteSpace calcs..
double aspectRatio;
//Work out the resized dimensions
if (origImage.getHeight() > origImage.getWidth()) //If the pictures height is greater than the width then scale appropriately.
{
fHeight = Height; //Set the height to 60 as it is the biggest side.
aspectRatio = (double)origImage.getWidth() / (double)origImage.getHeight(); //Get the aspect ratio of the picture.
fWidth = (int)Math.round(Width * aspectRatio); //Sets the width as created via the aspect ratio.
}
else if (origImage.getHeight() < origImage.getWidth()) //If the pictures width is greater than the height scale appropriately.
{
fWidth = Width; //Set the height to 60 as it is the biggest side.
aspectRatio = (double)origImage.getHeight() / (double)origImage.getWidth(); //Get the aspect ratio of the picture.
fHeight = (int)Math.round(Height * aspectRatio); //Sets the height as created via the aspect ratio.
}
int extraHeight = whiteSpace - fHeight;
int extraWidth = whiteSpace - fWidth;
BufferedImage resizedImage = new BufferedImage(whiteSpace, whiteSpace, type);
Graphics2D g = resizedImage.createGraphics();
g.setColor(Color.white);
g.fillRect(0, 0, whiteSpace, whiteSpace);
g.setComposite(AlphaComposite.Src);
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.drawImage(origImage, extraWidth/2, extraHeight/2, fWidth, fHeight, null);
g.dispose();
ImageIO.write(resizedImage, "jpg", new File(destImg));
}
catch (IOException ex)
{
return false;
}
return true;
}
На самом деле просто нужно знать, может ли я включить их что-то, что повысит качество или мне нужно взглянуть на что-то еще целиком.
РЕДАКТИРОВАТЬ: Сравнение изображений.
Источник, только что выбрал случайную стиральную машину от гугла. http://www.essexappliances.co.uk/images/categories/washing-machine.jpg
Та же картинка конвертируется в фотошопе в то, что мне нужно. https://imgur.com/78B1p
Как это выглядит, будучи преобразованным вот так. https://imgur.com/8WlXD
4 ответа
Проблема, которую вы видите, на самом деле связана с фильтром повторной выборки, используемым для уменьшения масштаба. Очевидно, что используемая вашей библиотекой ситуация плохая. Ближайший сосед, билинейный и бикубический типичные плохие примеры, которые следует использовать при уменьшении масштаба. Я не знаю точного фильтра передискретизации, который использует Photoshop, но я использовал 3-лопастный Ланцош и получил следующий результат:
Итак, чтобы решить вашу проблему, вам нужно использовать более умный фильтр передискретизации.
Уменьшение изображения в большом диапазоне опасно (с точки зрения качества), особенно с использованием одного шага.
Рекомендуемый метод - использовать метод "разделяй и властвуй". По сути, вы уменьшаете изображение с шагом 50%, пока не достигнете желаемого размера.
Итак, я взял исходное изображение размером 650x748 и уменьшил его до размера 60x60 (52x60).
Разделяй и властвуй по сравнению с одним шагом...
public class TestImageResize {
public static void main(String[] args) {
new TestImageResize();
}
public TestImageResize() {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception ex) {
}
JFrame frame = new JFrame("Testing");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLayout(new BorderLayout());
frame.add(new ScalePane());
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
});
}
public class ScalePane extends JPanel {
private BufferedImage original;
private BufferedImage scaled;
public ScalePane() {
try {
original = ImageIO.read(new File("path/to/master.jpg"));
scaled = getScaledInstanceToFit(original, new Dimension(60, 60));
ImageIO.write(scaled, "jpg", new File("scaled.jpg"));
BufferedImage image = new BufferedImage(52, 60, BufferedImage.TYPE_INT_RGB);
Graphics2D g2d = image.createGraphics();
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.drawImage(original, 0, 0, 52, 60, this);
g2d.dispose();
ImageIO.write(image, "jpg", new File("test.jpg"));
} catch (IOException ex) {
ex.printStackTrace();
}
}
@Override
public Dimension getPreferredSize() {
Dimension size = super.getPreferredSize();
if (original != null) {
if (scaled != null) {
size.width = original.getWidth() + scaled.getWidth();
size.height = original.getHeight();
} else {
size.width = original.getWidth();
size.height = original.getHeight();
}
}
return size;
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g.create();
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
if (original != null) {
int x = 0;
int y = (getHeight() - original.getHeight()) / 2;;
if (scaled != null) {
x = (getWidth() - (original.getWidth() + scaled.getWidth())) / 2;
} else {
x = (getWidth() - original.getWidth()) / 2;
}
g2d.drawImage(original, x, y, this);
if (scaled != null) {
x += original.getWidth();
y = (getHeight() - scaled.getHeight()) / 2;
g2d.drawImage(scaled, x, y, this);
}
}
g2d.dispose();
}
public BufferedImage getScaledInstanceToFit(BufferedImage img, Dimension size) {
float scaleFactor = getScaleFactorToFit(img, size);
return getScaledInstance(img, scaleFactor);
}
public float getScaleFactorToFit(BufferedImage img, Dimension size) {
float scale = 1f;
if (img != null) {
int imageWidth = img.getWidth();
int imageHeight = img.getHeight();
scale = getScaleFactorToFit(new Dimension(imageWidth, imageHeight), size);
}
return scale;
}
public float getScaleFactorToFit(Dimension original, Dimension toFit) {
float scale = 1f;
if (original != null && toFit != null) {
float dScaleWidth = getScaleFactor(original.width, toFit.width);
float dScaleHeight = getScaleFactor(original.height, toFit.height);
scale = Math.min(dScaleHeight, dScaleWidth);
}
return scale;
}
public float getScaleFactor(int iMasterSize, int iTargetSize) {
float scale = 1;
if (iMasterSize > iTargetSize) {
scale = (float) iTargetSize / (float) iMasterSize;
} else {
scale = (float) iTargetSize / (float) iMasterSize;
}
return scale;
}
public BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor) {
BufferedImage imgBuffer = null;
imgBuffer = getScaledInstance(img, dScaleFactor, RenderingHints.VALUE_INTERPOLATION_BILINEAR, true);
return imgBuffer;
}
protected BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor, Object hint, boolean higherQuality) {
int targetWidth = (int) Math.round(img.getWidth() * dScaleFactor);
int targetHeight = (int) Math.round(img.getHeight() * dScaleFactor);
int type = (img.getTransparency() == Transparency.OPAQUE)
? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
BufferedImage ret = (BufferedImage) img;
if (targetHeight > 0 || targetWidth > 0) {
int w, h;
if (higherQuality) {
w = img.getWidth();
h = img.getHeight();
} else {
w = targetWidth;
h = targetHeight;
}
do {
if (higherQuality && w > targetWidth) {
w /= 2;
if (w < targetWidth) {
w = targetWidth;
}
}
if (higherQuality && h > targetHeight) {
h /= 2;
if (h < targetHeight) {
h = targetHeight;
}
}
BufferedImage tmp = new BufferedImage(Math.max(w, 1), Math.max(h, 1), type);
Graphics2D g2 = tmp.createGraphics();
g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
g2.drawImage(ret, 0, 0, w, h, null);
g2.dispose();
ret = tmp;
} while (w != targetWidth || h != targetHeight);
} else {
ret = new BufferedImage(1, 1, type);
}
return ret;
}
}
}
Вы также можете найти Угрозы Image.getScaledInstance() интерес
Голландец, вот почему я поддерживаю библиотеку imgscalr - чтобы сделать такие вещи мучительно легкими.
В вашем примере, единственный вызов метода поможет вам сразу после вашей первой строки ImageIO.read:
origImage = ImageIO.read(new File(sourceImg));
Вы можете сделать следующее, чтобы получить то, что вы хотите ( javadoc для этого метода):
origImage = Scalr.resize(origImage, Method.ULTRA_QUALITY, 60);
и если это все еще выглядело немного неровно (поскольку вы удаляете так много информации из изображения, вы можете добавить следующую команду к команде, чтобы применить легкий фильтр сглаживания к изображению, чтобы оно выглядело более плавным):
origImage = Scalr.resize(origImage, Method.ULTRA_QUALITY, 60, Scalr.OP_ANTIALIAS);
Это заменит всю оставшуюся у вас логику кода. Единственное, что я бы порекомендовал, - это сохранить ваши действительно маленькие сэмплы в формате PNG, чтобы больше не было выполнено преобразование сжатия / с потерями на изображении ИЛИ убедитесь, что вы используете сжатие практически не на JPG, если вы действительно хотите использовать его в формате JPG. (Вот статья о том, как это сделать; она использует класс ImageWriteParam)
imgscalr лицензируется под лицензией Apache 2 и размещается на GitHub, поэтому вы можете делать с ним все, что хотите; он также включает поддержку асинхронного масштабирования, если вы используете библиотеку в приложении на стороне сервера и ставите в очередь огромное количество операций масштабирования и не хотите убивать сервер.
Как уже говорилось, Java2 Graphics2D не обеспечивает очень хороший алгоритм для уменьшения масштаба. Если вы не хотите реализовывать сложный алгоритм самостоятельно, вы можете попробовать текущие библиотеки с открытым исходным кодом, специализированные для этого: Thumbnailator, imgscalr и Java-интерфейс для ImageMagick.
При поиске частного проекта я опробовал их (кроме ImageMagick), и вот визуальные результаты с Photoshop в качестве ссылки:
A. Thumbnailator 0.4.8 с настройками по умолчанию (без дополнительного внутреннего изменения размера)
B. imgscalr 4.2 с настройкой ULTRA_QUALTY
C. Бикубический фильтр Photoshop CS5 (за исключением веб-страниц)
D. Graphics2d со всеми советами по визуализации в HQ
Thumbnailator и PS дают похожие результаты, в то время как imgscalr кажется более мягким. Это субъективно, какая из библиотек создает предпочтительные результаты. Еще один момент, чтобы рассмотреть, хотя это производительность. Хотя Thumbnailator и Graphics2d имеют одинаковое время выполнения, imgscalr значительно медленнее (с ULTRA_QUALITY) в моих тестах.