आप जावा में जेपीईजी से थंबनेल छवि कैसे बनाते हैं?

Question

क्या कोई जावा में जेपीईजी के लिए थंबनेल बनाने के लिए कुछ कोड के साथ मदद कर सकता है।

मैं इस पर नया हूं, इसलिए चरण-दर-चरण स्पष्टीकरण की सराहना की जाएगी।

Answer 1

Image img = ImageIO.read(new File("test.jpg")).getScaledInstance(100, 100, BufferedImage.SCALE_SMOOTH); 

यह एक छवि ऑब्जेक्ट के रूप में 100x100 पिक्सेल थंबनेल बनाएगा। आप इसे वापस डिस्क के लिए लिखना चाहते हैं, तो बस इस के लिए कोड में परिवर्तित:

BufferedImage img = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB); 
img.createGraphics().drawImage(ImageIO.read(new File("test.jpg")).getScaledInstance(100, 100, Image.SCALE_SMOOTH),0,0,null); 
ImageIO.write(img, "jpg", new File("test_thumb.jpg")); 

इसके अलावा, अगर आप गति मुद्दों के बारे में चिंतित हैं (विधि ऊपर वर्णित बल्कि धीमी है अगर आप कई छवियों पैमाने पर करना चाहते हैं) इन पद्धतियों का उपयोग और निम्नलिखित घोषणा:

private BufferedImage scale(BufferedImage source,double ratio) { 
    int w = (int) (source.getWidth() * ratio); 
    int h = (int) (source.getHeight() * ratio); 
    BufferedImage bi = getCompatibleImage(w, h); 
    Graphics2D g2d = bi.createGraphics(); 
    double xScale = (double) w/source.getWidth(); 
    double yScale = (double) h/source.getHeight(); 
    AffineTransform at = AffineTransform.getScaleInstance(xScale,yScale); 
    g2d.drawRenderedImage(source, at); 
    g2d.dispose(); 
    return bi; 
} 

private BufferedImage getCompatibleImage(int w, int h) { 
    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); 
    GraphicsDevice gd = ge.getDefaultScreenDevice(); 
    GraphicsConfiguration gc = gd.getDefaultConfiguration(); 
    BufferedImage image = gc.createCompatibleImage(w, h); 
    return image; 
} 

और फिर कहते हैं:

BufferedImage scaled = scale(img,0.5); 

जहां 0.5 पैमाने अनुपात है और img सामान्य आकार के चित्र वाली एक BufferedImage है।

Answer 2

JMagick लाइब्रेरी (और जावा में ImageMagick का कार्यान्वयन) आपको जो चाहिए वह होगा।

Answer 3

जावा कोड ऊपर (पैमाने के साथ/getCompatibleImage विधि) महान मेरे लिए काम किया, लेकिन जब मैं एक सर्वर के लिए तैनात किए गए हैं, यह काम करना बंद कर, क्योंकि सर्वर ने कोई प्रदर्शन इसके साथ जुड़े था - इस समस्या के साथ किसी और को यह कर सकते हैं इसका उपयोग करके इसे ठीक करें: BufferedImage bi = new BufferedImage (w, h, BufferedImage.TYPE_INT_RGB);

के बजाय BufferedImage bi = getCompatibleImage (w, h);

और getCompatibleImage विधि

(बाद में नोट को हटाने - यह पता चला है यह सबसे छवियों के लिए अच्छा काम करता है, लेकिन मैं अपने कंपनी के विपणन विभाग से एक गुच्छा है कि 32 बिट रंग गहराई jpeg चित्र हैं मिल गया है, और पुस्तकालय उन सभी के लिए एक असमर्थित छवि प्रारूप अपवाद फेंकता है :(- imagemagick/jmagick अधिक आकर्षक लगने लग रहे हैं)

Answer 4

जैसा कि आपको "आसान" और "अच्छा दिखने वाला परिणाम" दो अलग-अलग चीजें मिल सकती हैं। इन दोनों आवश्यकताओं को एक बहुत ही सरल java image scaling library (अपाचे 2 लाइसेंस) में encapsulated है जो सिर्फ आपके लिए सबकुछ सही करता है।

उदाहरण थंबनेल बनाने का कोड इस तरह दिखता है:

BufferedImage img = ImageIO.read(...); // load image 
BufferedImage scaledImg = Scalr.resize(img, 150); 

आपकी छवि अनुपात सम्मानित किया जाता है, पुस्तकालय विधि यह कारण करने के लिए छवि में परिवर्तन की मात्रा के आधार पर उपयोग किसे करना चाहिए पर एक सबसे लगता है कि बनाता है स्केलिंग (फास्टस्ट, बैलेंस्ड या क्वालिटी) और सबसे अच्छा समर्थित जावा 2 डी छवि प्रकार हमेशा "काले" परिणामों के मुद्दे से बचने के लिए स्केलिंग करने के लिए उपयोग किए जाते हैं या वास्तव में भयानक दिखने वाले आउटपुट (उदाहरण के लिए) अत्यधिक dithered जीआईएफ छवियों)।

इसके अलावा, अगर आप उत्पादन के लिए यह जावा में सबसे अच्छी स्थिति में थंबनेल संभव बाध्य करना चाहते हैं, API कॉल इस प्रकार दिखाई देगा:

BufferedImage img = ImageIO.read(...); // load image 
BufferedImage scaledImg = Scalr.resize(img, Method.QUALITY, 
             150, 100, Scalr.OP_ANTIALIAS); 

इतना ही पुस्तकालय का उपयोग करेगा Java2D आप के लिए वृद्धिशील स्केलिंग की सिफारिश की आपको सबसे अच्छा दिखने वाला परिणाम देने के लिए, यह थंबनेल (कन्वोलवेऑप को बहुत ही अच्छे-ट्यून किए गए कर्नेल के साथ) पर वैकल्पिक एंटीअलाइजिंग प्रभाव भी लागू करेगा ताकि पिक्सेल मानों के बीच संक्रमण को थोड़ा नरम कर दिया जा सके ताकि थंबनेल अधिक समान दिखाई दे और न हो तेज या अफीम जैसा कि आपने देखा होगा जब आप बहुत बड़ी छवियों से बहुत छोटे लोगों तक जाते हैं।

आप लाइब्रेरी में सभी टिप्पणियों के माध्यम से पढ़ सकते हैं (कोड स्वयं को बहुत ही कम किया गया है) प्रदर्शन या स्मृति उपयोग को बेहतर बनाने के लिए किए गए सभी अलग-अलग जेडीके बग्स या ऑप्टिमाइज़ेशन को देखने के लिए। मैंने इस कार्यान्वयन को ट्यून करने में काफी समय बिताया और वेब ऐप्स और अन्य जावा परियोजनाओं में इसे तैनात करने वाले लोगों से बहुत अच्छी प्रतिक्रिया मिली है।

Answer 5

छवि में किसी भी खिंचाव या स्केव के बिना 100 एक्स 100 थंबनेल बनाने का यह आसान तरीका है।

private void saveScaledImage(String filePath,String outputFile){ 
    try { 

     BufferedImage sourceImage = ImageIO.read(new File(filePath)); 
     int width = sourceImage.getWidth(); 
     int height = sourceImage.getHeight(); 

     if(width>height){ 
      float extraSize= height-100; 
      float percentHight = (extraSize/height)*100; 
      float percentWidth = width - ((width/100)*percentHight); 
      BufferedImage img = new BufferedImage((int)percentWidth, 100, BufferedImage.TYPE_INT_RGB); 
      Image scaledImage = sourceImage.getScaledInstance((int)percentWidth, 100, Image.SCALE_SMOOTH); 
      img.createGraphics().drawImage(scaledImage, 0, 0, null); 
      BufferedImage img2 = new BufferedImage(100, 100 ,BufferedImage.TYPE_INT_RGB); 
      img2 = img.getSubimage((int)((percentWidth-100)/2), 0, 100, 100); 

      ImageIO.write(img2, "jpg", new File(outputFile));  
     }else{ 
      float extraSize= width-100; 
      float percentWidth = (extraSize/width)*100; 
      float percentHight = height - ((height/100)*percentWidth); 
      BufferedImage img = new BufferedImage(100, (int)percentHight, BufferedImage.TYPE_INT_RGB); 
      Image scaledImage = sourceImage.getScaledInstance(100,(int)percentHight, Image.SCALE_SMOOTH); 
      img.createGraphics().drawImage(scaledImage, 0, 0, null); 
      BufferedImage img2 = new BufferedImage(100, 100 ,BufferedImage.TYPE_INT_RGB); 
      img2 = img.getSubimage(0, (int)((percentHight-100)/2), 100, 100); 

      ImageIO.write(img2, "jpg", new File(outputFile)); 
     } 

    } catch (IOException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 

} 

Answer 6

मैं एक आवेदन बुलाया fotovault (sourceforge.net) जो छवियों को अपलोड और एपीआई ImageJ का उपयोग जावा में थंबनेल बना सकते हैं बनाया है।

नीचे

http://www.gingercart.com/Home/java-snippets/create-image-thumbnail-in-java-using-imagej-api

Answer 7

मैं एक ब्लॉग है, जिसमें आप निम्नलिखित है विकल्पों अनुसार माध्यम से चले गए मेरे ब्लॉग को पढ़ने के लिए कृपया -

1. सरल आरजीबी फ़ाइलों के लिए ImageScalr का उपयोग करें। छवियों का वर्ग थंबनेल बनाने के लिए फ़ाइलों और छविस्केलर पढ़ने के लिए उपयोग किया जाता है
2. आरजीबी + सीवाईएमके का समर्थन करने के लिए, छवियों और छवि (एसएक्सएमएलआर) को पढ़ने के लिए छवियों और जेएआई (जावा उन्नत इमेजिंग) एपीआई का उपयोग थंबनेल बनाने के लिए करें।
3. यदि आपको नहीं पता कि फ़ाइल प्रारूप, रंग मोड आप किससे निपटने जा रहे हैं, तो सबसे सुरक्षित विकल्प ImageMagick का उपयोग करना है।

यहां link है जो कोड स्निपेट के साथ एक पूर्ण उत्तर देता है।

Answer 8

मैंने थंबनेलेटर का उपयोग किया है! इसने कोड की दो पंक्तियों के साथ अपनी समस्या हल की।

https://github.com/coobird/thumbnailator

Answer 9

कई छवि प्रसंस्करण चौखटे उपलब्ध आपको बस कुछ ही लाइनों के साथ ऐसा कर सकते हैं। नीचे दिया गया उदाहरण Marvin Framework का उपयोग करके विभिन्न संकल्पों (संदर्भ के रूप में चौड़ाई दिया गया) में थंबनेल उत्पन्न करता है। तीन थंबनेल 92 एमएस में उत्पन्न किए गए थे।

इनपुट:

उत्पादन:

import static marvin.MarvinPluginCollection.*; 

MarvinImage image = MarvinImageIO.loadImage("./res/input.jpg"); 
MarvinImage scaledImage = new MarvinImage(1,1); 

scale(image, scaledImage, 250); 
MarvinImageIO.saveImage(scaledImage, "./res/output_x250.jpg"); 

scale(image, scaledImage, 150); 
MarvinImageIO.saveImage(scaledImage, "./res/output_x150.jpg"); 

scale(image, scaledImage, 50); 
MarvinImageIO.saveImage(scaledImage, "./res/output_x50.jpg"); 

Answer 10

खिंचाव या पुस्तकालय के बिना थंबनेल बनाने का सरल तरीका। पीएनजी में पारदर्शिता के साथ भी काम करता है।

public File createThumbnail(String imageUrl, String targetPath) { 
    final int imageSize = 100; 
    File thumbnail = new File(targetPath); 

    try { 
     thumbnail.getParentFile().mkdirs(); 
     thumbnail.createNewFile(); 
     BufferedImage sourceImage = ImageIO.read(new File(imageUrl)); 
     float width = sourceImage.getWidth(); 
     float height = sourceImage.getHeight(); 

     BufferedImage img2; 
     if (width > height) { 
      float scaledWidth = (width/height) * (float) imageSize; 
      float scaledHeight = imageSize; 

      BufferedImage img = new BufferedImage((int) scaledWidth, (int) scaledHeight, sourceImage.getType()); 
      Image scaledImage = sourceImage.getScaledInstance((int) scaledWidth, (int) scaledHeight, Image.SCALE_SMOOTH); 
      img.createGraphics().drawImage(scaledImage, 0, 0, null); 

      int offset = (int) ((scaledWidth - scaledHeight)/2f); 
      img2 = img.getSubimage(offset, 0, imageSize, imageSize); 
     } 
     else if (width < height) { 
      float scaledWidth = imageSize; 
      float scaledHeight = (height/width) * (float) imageSize; 

      BufferedImage img = new BufferedImage((int) scaledWidth, (int) scaledHeight, sourceImage.getType()); 
      Image scaledImage = sourceImage.getScaledInstance((int) scaledWidth, (int) scaledHeight, Image.SCALE_SMOOTH); 
      img.createGraphics().drawImage(scaledImage, 0, 0, null); 

      int offset = (int) ((scaledHeight - scaledWidth)/2f); 
      img2 = img.getSubimage(0, offset, imageSize, imageSize); 
     } 
     else { 
      img2 = new BufferedImage(imageSize, imageSize, sourceImage.getType()); 
      Image scaledImage = sourceImage.getScaledInstance(imageSize, imageSize, Image.SCALE_SMOOTH); 
      img2.createGraphics().drawImage(scaledImage, 0, 0, null); 
     } 
     ImageIO.write(img2, "png", thumbnail); 
    } 
    catch (IOException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    return thumbnail; 
} 

Answer 11

मेरे पास जेएआई का उपयोग करके कई वर्षों पहले स्थिर विधियों के साथ उपयोग कक्षा है। जावा उन्नत इमेजिंग एपीआई छवियों से निपटने के लिए जावा में सबसे विश्वसनीय एपीआई है। यह जावा दुनिया में फ़ोटोशॉप के लिए वेक्टर इंटरपोलेशन निकटतम चीज है। यहां उनमें से एक है:

public static ByteArrayOutputStream resize(InputStream inputStream , int IMG_WIDTH, 
     int IMG_HEIGHT) throws Exception { 
    BufferedImage originalImage = ImageIO.read(inputStream); 
    int type = originalImage.getType() == 0 ? BufferedImage.TYPE_INT_ARGB 
      : originalImage.getType(); 
    BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, 
      type); 
    { 
     Graphics2D g = resizedImage.createGraphics(); 
     g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_HEIGHT, null); 
     g.dispose(); 
     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); 
    } 
    ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
    ImageIO.write(resizedImage, "png", bos); 
    return bos; 

} 

Answer 12

मुझे पता है कि यह एक पुरानी पुरानी पोस्ट है। मैं एक समाधान थंबनेल उत्पन्न करने के लिए की तलाश में था इसलिए का उपयोग कर अंत इस

Thumbnails.of(originalImage).scale(0.25).asBufferedImage(); 

अगर आप मोबाइल के लिए उपयोग कर रहे हैं 0,45

Thumbnails.of(originalImage).scale(0.45).asBufferedImage(); 

https://github.com/coobird/thumbnailator

यह करने के लिए पैमाने पर सेट करने के लिए सुझाव है कि ग्राफिक्स 2 डी का उपयोग करके निश्चित रूप से बहुत तेज़ है क्योंकि दोनों विकल्पों का परीक्षण किया गया है।