Przejdź do JP2 przez Java
Twórz własne aplikacje Java, aby scalać pliki JP2 za pomocą interfejsów API po stronie serwera.
Aspose.Imaging dla Java
Overview
Jak scalić pliki JP2 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 JP2, 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 JP2s przez Java
Potrzebujesz aspose-imaging-version-jdk16.jar aby wypróbować następujący przepływ pracy we własnym środowisku.
- Załaduj pliki JP2 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 JP2 – 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 JP2s przez aplikację online
Połącz dokumenty JP2, odwiedzając naszą witrynę demonstracyjną na żywo . Demo na żywo ma następujące zalety
JP2 Co jest JP2 Format pliku
JPEG 2000 (JP2) to system kodowania obrazu i najnowocześniejszy standard kompresji obrazu. Zaprojektowany przy użyciu technologii wavelet JPEG 2000 może kodować bezstratne treści w dowolnej jakości na raz. Co więcej, bez znaczącej utraty wydajności kodowania, JPEG 2000 ma możliwość dostępu i efektywnego dekodowania tej samej treści w różnych innych rozdzielczościach i jakościach. Strumienie kodu w JPEG 2000 są znacznie skalowalne, posiadając obszary zainteresowania, które zapewniają możliwość przestrzennego dostępu losowego. Posiada do 16384 różnych komponentów o wymiarach w terapikselach i precyzji, która może sięgać nawet 38 bitów na próbkę.
Czytaj więcejInne obsługiwane formaty scalania
Za pomocą Java można łatwo łączyć różne formaty, w tym.