Przejdź do WEBP przez Java
Twórz własne aplikacje Java, aby scalać pliki WEBP za pomocą interfejsów API po stronie serwera.
Aspose.Imaging dla Java
Overview
Jak scalić pliki WEBP za pomocą Java
Jeśli chcesz puścić wodze fantazji, nadszedł czas, aby skorzystać z kolażu obrazów. Ta funkcja umożliwia łączenie zdjęć i obrazów, nawet jeśli pliki źródłowe mają różne formaty. Świetnym sposobem na zwrócenie uwagi na swoje portfolio jest zastosowanie fototapet z powtarzającymi się obrazami lub wzorami. W takim przypadku obrazy można łączyć zarówno w kierunku poziomym, jak i pionowym. Jeśli chcesz zademonstrować wynik obróbki pliku, możesz łatwo połączyć dwa obrazy: przed i po zastosowaniu efektu fotograficznego. Aby połączyć pliki WEBP, użyjemy Aspose.Imaging dla Javy API, który jest bogatym w funkcje, wydajnym i łatwym w użyciu interfejsem API do obróbki i konwersji obrazów dla platformy Java. Możesz pobrać jego najnowszą wersję bezpośrednio z Maven i zainstaluj go w swoim projekcie opartym na Maven, dodając następujące konfiguracje do pom.xml.
Repozytorium
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>https://repository.aspose.com/repo/</url>
</repository>
Zależność
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-imaging</artifactId>
<version>version of aspose-imaging API</version>
<classifier>jdk16</classifier>
</dependency>
Kroki do scalenia WEBPs przez Java
Potrzebujesz aspose-imaging-version-jdk16.jar aby wypróbować następujący przepływ pracy we własnym środowisku.
- Załaduj pliki WEBP za pomocą metody Image.load
- Łączenie obrazów w nowe
- Zapisz przycięty obraz na dysku w formacie obsługiwanym przez Aspose.Imaging
wymagania systemowe
Aspose.Imaging dla Java jest obsługiwane we wszystkich głównych systemach operacyjnych. Tylko upewnij się, że masz następujące wymagania wstępne.
- JDK 1.6 lub nowszy jest zainstalowany.
Scal obrazy WEBP – Java
| import com.aspose.imaging.Color; | |
| import com.aspose.imaging.Graphics; | |
| import com.aspose.imaging.Image; | |
| import com.aspose.imaging.RectangleF; | |
| import com.aspose.imaging.fileformats.png.PngColorType; | |
| import com.aspose.imaging.imageoptions.PngOptions; | |
| import com.aspose.imaging.sources.StreamSource; | |
| import java.io.File; | |
| import java.io.FilenameFilter; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| enum MergeStyle | |
| { | |
| Horizontal, | |
| Vertical | |
| } | |
| // Test directory should have source images to merge | |
| String TestDirectory = "D:\\Many2One\\"; | |
| MergeStyle mStyle = MergeStyle.Horizontal; // or MergeStyle.Vertical | |
| List<Image> images = new ArrayList<Image>(); | |
| try | |
| { | |
| int totalWidth = 0; | |
| int totalHeight = 0; | |
| int maxWidth = 0; | |
| int maxHeight = 0; | |
| final String fileMask = ".png"; | |
| File[] files = new File(TestDirectory).listFiles(new FilenameFilter() | |
| { | |
| @Override | |
| public boolean accept(File dir, String name) | |
| { | |
| return name.endsWith(fileMask); | |
| } | |
| }); | |
| if (files == null) | |
| { | |
| return; | |
| } | |
| for (File fileName : files) | |
| { | |
| try (Image image = Image.load(fileName.getAbsolutePath())) | |
| { | |
| totalWidth += image.getWidth(); | |
| if (image.getWidth() > maxWidth) | |
| { | |
| maxWidth = image.getWidth(); | |
| } | |
| totalHeight += image.getHeight(); | |
| if (image.getHeight() > maxHeight) | |
| { | |
| maxHeight = image.getHeight(); | |
| } | |
| images.add(image); | |
| } | |
| } | |
| if (images.isEmpty()) | |
| { | |
| return; | |
| } | |
| String mergeStyle; | |
| int targetWidth, targetHeight; | |
| if (mStyle == MergeStyle.Horizontal) | |
| { | |
| targetWidth = totalWidth; | |
| targetHeight = maxHeight; | |
| } | |
| else if (mStyle == MergeStyle.Vertical) | |
| { | |
| targetWidth = maxWidth; | |
| targetHeight = totalHeight; | |
| } | |
| else | |
| { | |
| return; // other merge styles are not supported | |
| } | |
| String outputPath = TestDirectory + "output\\"; | |
| File dir = new File(outputPath); | |
| assert dir.exists() || dir.mkdirs(); | |
| outputPath = outputPath + "merged_" + mStyle.name() + ".png"); | |
| PngOptions pngOptions = new PngOptions(); | |
| pngOptions.setColorType(PngColorType.TruecolorWithAlpha); | |
| pngOptions.setSource(new StreamSource()); | |
| try (Image image = Image.create(pngOptions, targetWidth, targetHeight)) | |
| { | |
| image.setBackgroundColor(Color.getWhite()); | |
| final Graphics graphics = new Graphics(image); | |
| float x = 0, y = 0; | |
| for (Image it : images) | |
| { | |
| graphics.drawImage(it, new RectangleF(x, y, it.getWidth(), it.getHeight())); | |
| if (mStyle == MergeStyle.Horizontal) | |
| { | |
| x += it.getWidth(); | |
| } | |
| if (mStyle == MergeStyle.Vertical) | |
| { | |
| y += it.getHeight(); | |
| } | |
| } | |
| image.save(outputPath); | |
| } | |
| } | |
| finally | |
| { | |
| for (Image image : images) | |
| { | |
| image.close(); | |
| } | |
| images.clear(); | |
| } |
Informacje o Aspose.Imaging dla Java API
Aspose.Imaging API to rozwiązanie do przetwarzania obrazów do tworzenia, modyfikowania, rysowania lub konwertowania obrazów (zdjęć) w aplikacjach. Oferuje: wieloplatformowe przetwarzanie obrazu, w tym między innymi konwersje między różnymi formatami obrazu (w tym jednolite przetwarzanie obrazu wielostronicowego lub wieloklatkowego), modyfikacje takie jak rysowanie, praca z prymitywami graficznymi, przekształcenia (zmiana rozmiaru, przycinanie, odwracanie i obracanie , binaryzacja, skala szarości, dostosowanie), zaawansowane funkcje manipulacji obrazem (filtrowanie, dithering, maskowanie, prostowanie) oraz strategie optymalizacji pamięci. Jest to samodzielna biblioteka i nie zależy od żadnego oprogramowania do obsługi obrazów. W projektach można łatwo dodać wysokowydajne funkcje konwersji obrazów za pomocą natywnych interfejsów API. Są to w 100% prywatne lokalne interfejsy API, a obrazy są przetwarzane na Twoich serwerach.Scal WEBPs przez aplikację online
Połącz dokumenty WEBP, odwiedzając naszą witrynę demonstracyjną na żywo . Demo na żywo ma następujące zalety
WEBP Co jest WEBP Format pliku
WebP, wprowadzony przez Google, to nowoczesny rastrowy format plików obrazów internetowych, oparty na bezstratnej i stratnej kompresji. Zapewnia tę samą jakość obrazu, jednocześnie znacznie zmniejszając rozmiar obrazu. Ponieważ większość stron internetowych wykorzystuje obrazy jako efektywną reprezentację danych, użycie obrazów WebP na stronach internetowych powoduje szybsze ładowanie stron internetowych. Według Google, bezstratne obrazy WebP są o 26% mniejsze w porównaniu do plików PNG, podczas gdy stratne obrazy WebP są o 25-34% mniejsze niż porównywalne obrazy JPEG. Obrazy są porównywane na podstawie indeksu podobieństwa strukturalnego (SSIM) między WebP a innymi formatami plików graficznych. WebP to siostrzany projekt formatu kontenera multimedialnego WebM.
Czytaj więcejInne obsługiwane formaty scalania
Za pomocą Java można łatwo łączyć różne formaty, w tym.