दो छवियों को मर्ज करना

Question

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

क्या कोई मेरी मदद कर सकता है? धन्यवाद!

विवरण: पारदर्शिता बनाए रखने वाली दो छवियों को मर्ज करें। मुझे यही करना है।

नोट: जावा में यह सेट बफ़र्डइमेज अल्फा मास्क वह नहीं करता है जो मुझे चाहिए क्योंकि यह दो छवियों के साथ अच्छी तरह से पारदर्शिता नहीं रखता है - यह पहली तस्वीर पारदर्शिता को संशोधित करता है।

Answer 1

बस पारदर्शिता के साथ एक नया बफ़रमैडम बनाएं, फिर उस पर अन्य दो छवियों (पूर्ण या अर्ध-पारदर्शिता के साथ) को पेंट करें। यह इस तरह दिखेगा:

नमूना कोड (छवियों को 'image.png' और 'overlay.png' कहा जाता है):

File path = ... // base path of the images

// load source images
BufferedImage image = ImageIO.read(new File(path, "image.png"));
BufferedImage overlay = ImageIO.read(new File(path, "overlay.png"));

// create the new image, canvas size is the max. of both image sizes
int w = Math.max(image.getWidth(), overlay.getWidth());
int h = Math.max(image.getHeight(), overlay.getHeight());
BufferedImage combined = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

// paint both images, preserving the alpha channels
Graphics g = combined.getGraphics();
g.drawImage(image, 0, 0, null);
g.drawImage(overlay, 0, 0, null);

g.dispose();

// Save as new image
ImageIO.write(combined, "PNG", new File(path, "combined.png"));

Comments

क्या पहली के केंद्र में दूसरी छवि है?

— अहमद

क्या आपको g.dispose () का आह्वान नहीं करना चाहिए; अतं मै?

— m-szalik

नमस्ते, मैंने इस दृष्टिकोण का अनुसरण किया और केवल दूसरी छवि को सहेजा, लेकिन पहली छवि को नहीं ... यहां किसी भी मदद की सराहना की जाएगी ..

— TP_JAVA

@Peter संयुक्त फाइल को jpeg फ़ाइल के रूप में सही करने पर छवि को बाहर निकाला जा रहा है। कृपया मदद करें

— मोहम्मद शबिन

Answer 2

मैं आपको एक विशिष्ट उत्तर नहीं दे सकता, लेकिन यहाँ java.awt.AlphaComposite आपका मित्र है। आप इस बात पर पूर्ण नियंत्रण प्राप्त करेंगे कि आप कैसे दो छवियों को मर्ज करना चाहते हैं। हालांकि यह उपयोग करने के लिए सीधा नहीं है - आपको पहले ग्राफिक्स सिद्धांत का एक सा सीखने की जरूरत है।

Answer 3

आप जिस प्रभाव को प्राप्त करने की कोशिश कर रहे हैं, उसके बारे में अधिक जानकारी के बिना, मैं सिर्फ यह बताऊंगा कि आप बफ़रेडमैज पर भी अधिकार बना सकते हैं। तो कुछ भी आप स्क्रीन पर कर सकते हैं आप छवि पर ही सही कर सकते हैं।

इसलिए यदि आप चाहते हैं कि एक दूसरे के ऊपर से एक खींचा जाए, तो यह वास्तव में आसान है। बस आधार छवि के लिए ग्राफिक्स ऑब्जेक्ट को पकड़ो और दूसरे को उस पर ड्रा करें।

फिर, उस सटीक प्रभाव पर निर्भर करता है, जिसके लिए आप काम कर रहे हैं। अधिक विस्तार से बेहतर मदद मिलेगी। उदाहरण के लिए, क्या यह अन्य उत्तरदाता उल्लेख या एक कस्टम ImageOp (या मौजूदा ImageOps के कुछ संयोजन) के रूप में AlphaComposite के लिए एक नौकरी है।

Answer 4

किसी भी प्रकार की फ़ाइल को लंबवत रूप से मर्ज करें।

void mergeFiles(List<String> files, String fileName) {
        int heightTotal = 0;
        int maxWidth = 100;

        List<BufferedImage> images = new ArrayList<>();
        try {
            for (String file : files) {
                BufferedImage image = ImageIO.read(new File(file));
                images.add(image);
            }


        for (BufferedImage bufferedImage : images) {
            heightTotal += bufferedImage.getHeight();
            if (bufferedImage.getWidth() > maxWidth) {
                maxWidth = bufferedImage.getWidth();
            }
        }


        int heightCurr = 0;
        BufferedImage concatImage = new BufferedImage(maxWidth, heightTotal, BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = concatImage.createGraphics();
        for (BufferedImage bufferedImage : images) {
            g2d.drawImage(bufferedImage, 0, heightCurr, null);
            heightCurr += bufferedImage.getHeight();
        }

        File compressedImageFile = new File(fileName);
        OutputStream outputStream = new FileOutputStream(compressedImageFile);

        float imageQuality = 0.7f;
        Iterator<ImageWriter> imageWriters = ImageIO.getImageWritersByFormatName("jpeg");

        if (!imageWriters.hasNext())
            throw new IllegalStateException("Writers Not Found!!");

        ImageWriter imageWriter = imageWriters.next();
        ImageOutputStream imageOutputStream = ImageIO.createImageOutputStream(outputStream);
        imageWriter.setOutput(imageOutputStream);

        ImageWriteParam imageWriteParam = imageWriter.getDefaultWriteParam();

        //Set the compress quality metrics
        imageWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        imageWriteParam.setCompressionQuality(imageQuality);

        //Created image
        imageWriter.write(null, new IIOImage(concatImage, null, null), imageWriteParam);

        // close all streams
        outputStream.close();
        imageOutputStream.close();
        imageWriter.dispose();
        log.info(" Files Merged");
        } catch (IOException e) {
            log.error("Error while merging files :::"+e);
            throw new RuntimeException(e);
        }
    }