लघु फ़ेकिंग

Question

जैसा कि कोई भी शौकिया फोटोग्राफर आपको बता सकता है, चरम-प्रसंस्करण हमेशा अच्छा होता है। ऐसी एक तकनीक को " मिनिएचर-फ़ेकिंग " कहा जाता है ।

वस्तु एक छवि बनाने के लिए है जैसे कि एक लघु, खिलौना संस्करण की एक तस्वीर। यह एक मध्यम / उच्च कोण से जमीन तक खींची गई तस्वीरों के लिए सबसे अच्छा काम करता है, विषय ऊंचाई में कम विचरण के साथ, लेकिन अन्य छवियों के लिए अलग-अलग प्रभावशीलता के साथ लागू किया जा सकता है।

चुनौती: एक तस्वीर लें और उस पर एक लघु-फ़ेकिंग एल्गोरिदम लागू करें। ऐसा करने के कई तरीके हैं, लेकिन इस चुनौती के उद्देश्यों के लिए, यह निम्नलिखित है:

• चयनात्मक धुंधला

  छवि का कुछ हिस्सा एक उथले गहराई के क्षेत्र का अनुकरण करने के लिए धुंधला होना चाहिए। यह आमतौर पर कुछ ढाल के साथ किया जाता है, चाहे रैखिक या आकार। जो भी ब्लर / ग्रेडिएंट अल्गोरिदम आपको पसंद है उसे चुनें, लेकिन 15-85% इमेज के बीच "ध्यान देने योग्य" ब्लर होना चाहिए।

• संतृप्ति को बढ़ावा

  चीजों को बनाने के लिए रंग को पंप करें ताकि वे हाथ से चित्रित हो सकें। इनपुट की तुलना में आउटपुट का औसत संतृप्ति स्तर> + 5% होना चाहिए। ( एचएसवी संतृप्ति का उपयोग करते हुए )

• कंट्रास्ट बूस्ट

  विपरीत प्रकाश व्यवस्था की स्थिति (जैसे कि आप सूर्य के बजाय एक इनडोर / स्टूडियो प्रकाश के साथ देखते हैं) का अनुकरण करने के लिए इसके विपरीत को बढ़ाएं। इनपुट की तुलना में आउटपुट का कंट्रास्ट + + 5% होना चाहिए। ( RMS एल्गोरिथ्म का उपयोग करके )

उन तीन परिवर्तनों को लागू किया जाना चाहिए, और किसी अन्य संवर्द्धन / परिवर्तन की अनुमति नहीं है। कोई फसल, पैनापन, सफेद संतुलन समायोजन, कुछ भी नहीं।

• इनपुट एक छवि है, और इसे फ़ाइल या मेमोरी से पढ़ा जा सकता है। आप छवि को पढ़ने और लिखने के लिए बाहरी पुस्तकालयों का उपयोग कर सकते हैं , लेकिन आप छवि को संसाधित करने के लिए उनका उपयोग नहीं कर सकते । इस उद्देश्य के लिए पूरक कार्य भी अस्वीकृत हैं (आप Image.blur()उदाहरण के लिए कॉल नहीं कर सकते )

• कोई और इनपुट नहीं है। प्रसंस्करण शक्ति, स्तर, आदि, कार्यक्रम द्वारा निर्धारित किया जाना चाहिए, न कि मानव द्वारा।

• आउटपुट को एक मानकीकृत छवि प्रारूप (पीएनजी, बीएमपी, आदि) में एक फ़ाइल के रूप में प्रदर्शित या बचाया जा सकता है।

• सामान्य करने का प्रयास करें। यह केवल एक छवि पर काम नहीं करना चाहिए , लेकिन यह समझ में आता है कि यह सभी छवियों पर काम नहीं करेगा । कुछ दृश्य बस इस तकनीक का अच्छा जवाब नहीं देते हैं, भले ही एल्गोरिथ्म कितना भी अच्छा क्यों न हो। उत्तर देने और मतदान करने के दौरान, यहां सामान्य ज्ञान लागू करें।

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

• अपने उत्तर में कम से कम दो आउटपुट चित्र शामिल करें:

  इस ड्रॉपबॉक्स फ़ोल्डर में छवियों में से एक से उत्पन्न होना चाहिए । चुनने के लिए छह हैं, लेकिन मैंने उन सभी को अलग-अलग डिग्री के लिए व्यवहार्य बनाने की कोशिश की। आप example-outputsसबफ़ोल्डर में प्रत्येक के लिए नमूना आउटपुट देख सकते हैं । कृपया ध्यान दें कि ये पूर्ण 10MP JPG चित्र सीधे कैमरे से बाहर हैं, इसलिए आपके पास काम करने के लिए बहुत सारे पिक्सेल हैं।

  दूसरा आपकी पसंद की कोई भी छवि हो सकती है। जाहिर है, उन छवियों को चुनने की कोशिश करें जो स्वतंत्र रूप से उपयोग करने योग्य हैं। इसके अलावा, मूल छवि या तुलना के लिए एक लिंक शामिल करें।

---

उदाहरण के लिए, इस छवि से:

आप कुछ इस तरह का उत्पादन कर सकते हैं:

संदर्भ के लिए, ऊपर के उदाहरण को जीआईएमपी में कोणीय बॉक्स के आकार के ढाल वाले गॉसियन ब्लर, संतृप्ति +80, कंट्रास्ट +20 के साथ संसाधित किया गया था। (मुझे नहीं पता कि GIMP उन इकाइयों के लिए क्या उपयोग करता है)

अधिक प्रेरणा के लिए, या एक बेहतर विचार प्राप्त करने के लिए कि आप क्या हासिल करने की कोशिश कर रहे हैं, इस साइट या इस एक को देखें । तुम भी खोज सकते हैं miniature fakingऔर tilt shift photographyउदाहरण के लिए।

---

यह एक लोकप्रियता प्रतियोगिता है। मतदाता, उन प्रविष्टियों के लिए वोट करें जिन्हें आप उद्देश्य के लिए सही रहते हुए सबसे अच्छे लगते हैं।

---

स्पष्टीकरण:

स्पष्ट करना कि कौन से कार्य अस्वीकृत हैं, गणित के कार्यों पर प्रतिबंध लगाना मेरा उद्देश्य नहीं था । छवि हेरफेर कार्यों पर प्रतिबंध लगाना मेरा उद्देश्य था । हां, वहां कुछ ओवरलैप है, लेकिन एफएफटी, कन्वेंशन, मैट्रिक्स गणित, आदि जैसी चीजें कई अन्य क्षेत्रों में उपयोगी हैं। आपको एक फ़ंक्शन का उपयोग नहीं करना चाहिए जो बस एक छवि लेता है और ब्लर करता है। यदि आप एक उपयुक्त बनाने के लिए एक उपयुक्त mathy तरीका पाते हैं , तो वह उचित खेल है।

Comments

यू-सुंग चांग द्वारा डिजिटल टिल्ट-शिफ्ट इमेज प्रोसेसिंग पर यह उल्लेखनीय प्रदर्शन प्रदर्शन ।wolfram.com/DigitalTiltShiftPhotography, विपरीत, चमक और स्थानीय फ़ोकस को समायोजित करने के तरीकों के बारे में विचारों का एक धन प्रदान करता है (फोटो के अंडाकार या आयताकार क्षेत्र के भीतर) ) का उपयोग कर निर्मित मेथेमेटिका के कार्य ( GeometricTransformation, DistanceTransform, ImageAdd, ColorNegate, ImageMultiply, Rasterize, और ImageAdjust।) यहां तक कि इस तरह के उच्च स्तर छवि प्रसंस्करण कार्यों की मदद से, कोड 22 कश्मीर ले जाता है। उपयोगकर्ता इंटरफ़ेस के लिए कोड फिर भी बहुत छोटा है।

— डेविड 18

मुझे कहना चाहिए था " केवल 22 k लगते हैं "। उपर्युक्त कार्यों में बहुत पीछे-पीछे दृश्य कोड है जो इस चुनौती के लिए एक सफल प्रतिक्रिया बहुत साबित होनी चाहिए, समर्पित छवि-प्रसंस्करण पुस्तकालयों का उपयोग किए बिना अधिकांश भाषाओं में प्राप्त करना बहुत मुश्किल है।

— डेविड

अपडेट: यह 2.5 k अक्षरों में किया गया था इसलिए यह और भी अधिक कुशल था।

— डेविडक

@DavidCarraher यही कारण है कि मैंने स्पष्ट रूप से कल्पना को सीमित कर दिया है। यह सिर्फ कल्पना को कवर करने के लिए कुछ लिखना मुश्किल नहीं है, जैसा कि नीचे मेरे संदर्भ कार्यान्वयन 4.3 k के अक्षर में ungolfed Java में दिखाया गया है । मैं बिल्कुल पेशेवर-स्टूडियो-स्तरीय परिणामों की उम्मीद नहीं कर रहा हूं। बेशक, कुछ भी जो कल्पना से अधिक है (बेहतर परिणाम की ओर जाता है) को दिल से उभारना चाहिए, आईएमओ। मैं मानता हूँ कि यह एक नहीं है सरल चुनौती के लिए उत्कृष्टता पर है, लेकिन यह हो नहीं था। न्यूनतम प्रयास बुनियादी है, लेकिन "अच्छी" प्रविष्टियां आवश्यक रूप से अधिक शामिल होंगी।

— Geobits

एक और एल्गोरिथ्म है कि इन के साथ जोड़ा जा सकता है और भी अधिक ठोस "लघुचित्र" का उत्पादन करने के लिए छवि से छोटी सुविधाओं को फिल्टर करने के लिए तरंग अपघटन का उपयोग करना है, जबकि बड़ी सुविधाओं को तेज रखना।

— AJMansfield

Answer 1

जावा: संदर्भ कार्यान्वयन

यहां जावा में एक बुनियादी संदर्भ कार्यान्वयन है। यह उच्च-कोण शॉट्स पर सबसे अच्छा काम करता है, और यह बहुत ही अक्षम है।

धब्बा एक बहुत ही मूल बॉक्स धब्बा है, इसलिए यह एक ही पिक्सेल पर आवश्यकता से अधिक लूप करता है। इसके विपरीत और संतृप्ति को एक ही लूप में भी जोड़ा जा सकता है, लेकिन खर्च किए गए समय का अधिकांश हिस्सा धुंधला पर होता है, इसलिए इससे बहुत लाभ नहीं होगा। कहा जा रहा है, यह 2MP या तो के तहत छवियों पर काफी जल्दी काम करता है। 10MP की छवि को पूरा होने में कुछ समय लगा।

मूल रूप से कुछ भी लेकिन एक फ्लैट बॉक्स ब्लर का उपयोग करके ब्लर क्वालिटी को आसानी से बेहतर बनाया जा सकता है । इसके विपरीत / संतृप्ति एल्गोरिदम अपना काम करते हैं, इसलिए वहां कोई वास्तविक शिकायत नहीं है।

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

यह उपयोग करने के लिए सरल है; केवल फ़ाइल नाम को केवल तर्क के रूप में पास करें। यह PNG में इनपुट फाइल की परवाह किए बिना आउटपुट देता है।

उदाहरण:

ड्रॉपबॉक्स चयन से:

पोस्टिंग में आसानी के लिए इन पहली छवियों को छोटा किया जाता है। पूरे आकार में तस्वीर देखने के लिए क्लिक करें।

बाद:

पहले:

विविध चयन:

बाद:

पहले:

import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class MiniFake {

    int maxBlur;
    int maxDist;
    int width;
    int height;

    public static void main(String[] args) {
        if(args.length < 1) return;
        new MiniFake().run(args[0]);
    }

    void run(String filename){
        try{
            BufferedImage in = readImage(filename);
            BufferedImage out = blur(in);
            out = saturate(out, 0.8);
            out = contrast(out, 0.6);

            String[] tokens = filename.split("\\.");
            String outname = tokens[0];
            for(int i=1;i<tokens.length-1;i++)
                outname += "." + tokens[i];
            ImageIO.write(out, "png", new File(outname + "_post.png"));
            System.out.println("done");
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    BufferedImage contrast(BufferedImage in, double level){
        BufferedImage out = copyImage(in);
        long lumens=0;
        for(int x=0;x<width;x++)
            for(int y=0;y<height;y++){
                int color = out.getRGB(x,y);
                lumens += lumen(getR(color), getG(color), getB(color));
            }
        lumens /= (width * height);

        for(int x=0;x<width;x++)
            for(int y=0;y<height;y++){
                int color = out.getRGB(x,y);
                int r = getR(color);
                int g = getG(color);
                int b = getB(color);
                double ratio = ((double)lumen(r, g, b) / (double)lumens) - 1d;
                ratio *= (1+level) * 0.1;
                r += (int)(getR(color) * ratio+1);
                g += (int)(getG(color) * ratio+1);
                b += (int)(getB(color) * ratio+1);
                out.setRGB(x,y,getColor(clamp(r),clamp(g),clamp(b)));
            }   
        return out;
    }

    BufferedImage saturate(BufferedImage in, double level){
        BufferedImage out = copyImage(in);
        for(int x=0;x<width;x++)
            for(int y=0;y<height;y++){
                int color = out.getRGB(x,y);
                int r = getR(color);
                int g = getG(color);
                int b = getB(color);
                int brightness = Math.max(r, Math.max(g, b));
                int grey = (int)(Math.min(r, Math.min(g,b)) * level);
                if(brightness == grey)
                    continue;
                r -= grey;
                g -= grey;
                b -= grey;
                double ratio = brightness / (double)(brightness - grey);
                r = (int)(r * ratio);
                g = (int)(g * ratio);
                b = (int)(b * ratio);
                out.setRGB(x, y, getColor(clamp(r),clamp(g),clamp(b)));
            }
        return out;
    }


    BufferedImage blur(BufferedImage in){
        BufferedImage out = copyImage(in);
        int[] rgb = in.getRGB(0, 0, width, height, null, 0, width);
        for(int i=0;i<rgb.length;i++){
            double dist = Math.abs(getY(i)-(height/2));
            dist = dist * dist / maxDist;
            int r=0,g=0,b=0,p=0;
            for(int x=-maxBlur;x<=maxBlur;x++)
                for(int y=-maxBlur;y<=maxBlur;y++){
                    int xx = getX(i) + x;
                    int yy = getY(i) + y;
                    if(xx<0||xx>=width||yy<0||yy>=height)
                        continue;
                    int color = rgb[getPos(xx,yy)];
                    r += getR(color);
                    g += getG(color);
                    b += getB(color);
                    p++;
                }

            if(p>0){
                r /= p;
                g /= p;
                b /= p;
                int color = rgb[i];
                r = (int)((r*dist) + (getR(color) * (1 - dist)));
                g = (int)((g*dist) + (getG(color) * (1 - dist)));
                b = (int)((b*dist) + (getB(color) * (1 - dist)));
            } else {
                r = in.getRGB(getX(i), getY(i));
            }
            out.setRGB(getX(i), getY(i), getColor(r,g,b));
        }
        return out;
    }

    BufferedImage readImage(String filename) throws IOException{
         BufferedImage image = ImageIO.read(new File(filename));
         width = image.getWidth();
         height = image.getHeight();
         maxBlur = Math.max(width, height) / 100;
         maxDist =  (height/2)*(height/2);
         return image;
    }

    public BufferedImage copyImage(BufferedImage in){
        BufferedImage out = new BufferedImage(in.getWidth(), in.getHeight(), BufferedImage.TYPE_INT_ARGB);
        Graphics g = out.getGraphics();
        g.drawImage(in, 0, 0, null);
        g.dispose();
        return out;
    }

    static int clamp(int c){return c<0?0:c>255?255:c;}
    static int getColor(int a, int r, int g, int b){return (a << 24) | (r << 16) | (g << 8) | (b);}
    static int getColor(int r, int g, int b){return getColor(0xFF, r, g, b);}
    static int getR(int color){return color >> 16 & 0xFF;}
    static int getG(int color){return color >> 8 & 0xFF;}
    static int getB(int color){return color & 0xFF;}
    static int lumen(int r, int g, int b){return (r*299)+(g*587)+(b*114);}
    int getX(int pos){return pos % width;}
    int getY(int pos){return pos / width;}
    int getPos(int x, int y){return y*width+x;} 
}

Answer 2

सी#

किसी भी पुनरावृत्त बॉक्स ब्लर्स करने के बजाय, मैंने पूरे रास्ते में जाने और गॉसियन ब्लर लिखने का फैसला किया। GetPixelकॉल वास्तव में जब बड़े कर्नेल का उपयोग कर इसे धीमा है, लेकिन यह प्रयोग करने के तरीकों कन्वर्ट करने के लिए सार्थक वास्तव में नहीं है LockBitsजब तक कि हम कुछ बड़े चित्र प्रसंस्करण कर रहे थे।

कुछ उदाहरण नीचे दिए गए हैं, जो मेरे द्वारा तय किए गए डिफ़ॉल्ट ट्यूनिंग मापदंडों का उपयोग करते हैं (मैं ट्यूनिंग मापदंडों के साथ ज्यादा नहीं खेलता था, क्योंकि वे परीक्षण छवि के लिए अच्छा काम करते थे)।

प्रदान किए गए परीक्षण मामले के लिए ...

एक और ...

एक और ...

संतृप्ति और कंट्रास्ट बढ़ता है कोड से काफी सीधा होना चाहिए। मैं एचएसएल स्पेस में ऐसा करता हूं और इसे आरजीबी में बदल देता हूं।

2 डी गाऊसी कर्नेल आकार के आधार पर उत्पन्न होता है nनिर्दिष्ट, साथ:

EXP(-((x-x0)^2/2+(y-y0)^2/2)/2)

... और सभी कर्नेल मान असाइन किए जाने के बाद सामान्य किए जाते हैं। ध्यान दें A=sigma_x=sigma_y=1।

कर्नेल को कहां लगाना है, यह जानने के लिए, मैं ब्लर वेट का उपयोग करता हूं, जिसकी गणना:

SQRT([COS(PI*x_norm)^2 + COS(PI*y_norm)^2]/2)

... जो एक सभ्य प्रतिक्रिया देता है, अनिवार्य रूप से मूल्यों का एक दीर्घवृत्तीय बनाता है जो उस धब्बा से सुरक्षित होता है जो धीरे-धीरे आगे बढ़ता है। एक बैंड-पास फ़िल्टर अन्य समीकरणों (शायद कुछ प्रकार y=-x^2) के साथ मिलकर संभवतः कुछ छवियों के लिए बेहतर काम कर सकता है। मैं कॉशन के साथ गया था क्योंकि इसने मेरे द्वारा परीक्षण किए गए बेस केस के लिए अच्छी प्रतिक्रिया दी थी।

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace FakeMini
{
    static class Program
    {
        static void Main()
        {
            // Some tuning variables
            double saturationValue = 1.7;
            double contrastValue = 1.2;
            int gaussianSize = 13; // Must be odd and >1 (3, 5, 7...)

            // NxN Gaussian kernel
            int padding = gaussianSize / 2;
            double[,] kernel = GenerateGaussianKernel(gaussianSize);

            Bitmap src = null;
            using (var img = new Bitmap(File.OpenRead("in.jpg")))
            {
                src = new Bitmap(img);
            }

            // Bordering could be avoided by reflecting or wrapping instead
            // Also takes advantage of the fact that a new bitmap returns zeros from GetPixel
            Bitmap border = new Bitmap(src.Width + padding*2, src.Height + padding*2);

            // Get average intensity of entire image
            double intensity = 0;
            for (int x = 0; x < src.Width; x++)
            {
                for (int y = 0; y < src.Height; y++)
                {
                    intensity += src.GetPixel(x, y).GetBrightness();
                }
            }
            double averageIntensity = intensity / (src.Width * src.Height);

            // Modify saturation and contrast
            double brightness;
            double saturation;
            for (int x = 0; x < src.Width; x++)
            {
                for (int y = 0; y < src.Height; y++)
                {
                    Color oldPx = src.GetPixel(x, y);
                    brightness = oldPx.GetBrightness();
                    saturation = oldPx.GetSaturation() * saturationValue;

                    Color newPx = FromHSL(
                                oldPx.GetHue(),
                                Clamp(saturation, 0.0, 1.0),
                                Clamp(averageIntensity - (averageIntensity - brightness) * contrastValue, 0.0, 1.0));
                    src.SetPixel(x, y, newPx);
                    border.SetPixel(x+padding, y+padding, newPx);
                }
            }

            // Apply gaussian blur, weighted by corresponding sine value based on height
            double blurWeight;
            Color oldColor;
            Color newColor;
            for (int x = padding; x < src.Width+padding; x++)
            {
                for (int y = padding; y < src.Height+padding; y++)
                {
                    oldColor = border.GetPixel(x, y);
                    newColor = Convolve2D(
                        kernel,
                        GetNeighbours(border, gaussianSize, x, y)
                       );

                    // sqrt([cos(pi*x_norm)^2 + cos(pi*y_norm)^2]/2) gives a decent response
                    blurWeight = Clamp(Math.Sqrt(
                        Math.Pow(Math.Cos(Math.PI * (y - padding) / src.Height), 2) +
                        Math.Pow(Math.Cos(Math.PI * (x - padding) / src.Width), 2)/2.0), 0.0, 1.0);
                    src.SetPixel(
                        x - padding,
                        y - padding,
                        Color.FromArgb(
                            Convert.ToInt32(Math.Round(oldColor.R * (1 - blurWeight) + newColor.R * blurWeight)),
                            Convert.ToInt32(Math.Round(oldColor.G * (1 - blurWeight) + newColor.G * blurWeight)),
                            Convert.ToInt32(Math.Round(oldColor.B * (1 - blurWeight) + newColor.B * blurWeight))
                            )
                        );
                }
            }
            border.Dispose();

            // Configure some save parameters
            EncoderParameters ep = new EncoderParameters(3);
            ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 100L);
            ep.Param[1] = new EncoderParameter(System.Drawing.Imaging.Encoder.ScanMethod, (int)EncoderValue.ScanMethodInterlaced);
            ep.Param[2] = new EncoderParameter(System.Drawing.Imaging.Encoder.RenderMethod, (int)EncoderValue.RenderProgressive);
            ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo ici = null;
            foreach (ImageCodecInfo codec in codecs)
            {
                if (codec.MimeType == "image/jpeg")
                    ici = codec;
            }
            src.Save("out.jpg", ici, ep);
            src.Dispose();
        }

        // Create RGB from HSL
        // (C# BCL allows me to go one way but not the other...)
        private static Color FromHSL(double h, double s, double l)
        {
            int h0 = Convert.ToInt32(Math.Floor(h / 60.0));
            double c = (1.0 - Math.Abs(2.0 * l - 1.0)) * s;
            double x = (1.0 - Math.Abs((h / 60.0) % 2.0 - 1.0)) * c;
            double m = l - c / 2.0;
            int m0 = Convert.ToInt32(255 * m);
            int c0 = Convert.ToInt32(255*(c + m));
            int x0 = Convert.ToInt32(255*(x + m));
            switch (h0)
            {
                case 0:
                    return Color.FromArgb(255, c0, x0, m0);
                case 1:
                    return Color.FromArgb(255, x0, c0, m0);
                case 2:
                    return Color.FromArgb(255, m0, c0, x0);
                case 3:
                    return Color.FromArgb(255, m0, x0, c0);
                case 4:
                    return Color.FromArgb(255, x0, m0, c0);
                case 5:
                    return Color.FromArgb(255, c0, m0, x0);
            }
            return Color.FromArgb(255, m0, m0, m0);
        }

        // Just so I don't have to write "bool ? val : val" everywhere
        private static double Clamp(double val, double min, double max)
        {
            if (val >= max)
                return max;
            else if (val <= min)
                return min;
            else
                return val;
        }

        // Simple convolution as C# BCL doesn't appear to have any
        private static Color Convolve2D(double[,] k, Color[,] n)
        {
            double r = 0;
            double g = 0;
            double b = 0;
            for (int i=0; i<k.GetLength(0); i++)
            {
                for (int j=0; j<k.GetLength(1); j++)
                {
                    r += n[i,j].R * k[i,j];
                    g += n[i,j].G * k[i,j];
                    b += n[i,j].B * k[i,j];
                }
            }
            return Color.FromArgb(
                Convert.ToInt32(Math.Round(r)),
                Convert.ToInt32(Math.Round(g)),
                Convert.ToInt32(Math.Round(b)));
        }

        // Generates a simple 2D square (normalized) Gaussian kernel based on a size
        // No tuning parameters - just using sigma = 1 for each
        private static double [,] GenerateGaussianKernel(int n)
        {
            double[,] kernel = new double[n, n];
            double currentValue;
            double normTotal = 0;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    currentValue = Math.Exp(-(Math.Pow(i - n / 2, 2) + Math.Pow(j - n / 2, 2)) / 2.0);
                    kernel[i, j] = currentValue;
                    normTotal += currentValue;
                }
            }
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    kernel[i, j] /= normTotal;
                }
            }
            return kernel;
        }

        // Gets the neighbours around the current pixel
        private static Color[,] GetNeighbours(Bitmap bmp, int n, int x, int y)
        {
            Color[,] neighbours = new Color[n, n];
            for (int i = -n/2; i < n-n/2; i++)
            {
                for (int j = -n/2; j < n-n/2; j++)
                {
                    neighbours[i+n/2, j+n/2] = bmp.GetPixel(x + i, y + j);
                }
            }
            return neighbours;
        }
    }
}

Answer 3

जावा

गॉसियन कलंक का अनुकरण करते हुए, कई पासों को चलाने के लिए तेजी से चलने वाले औसत-टू-बॉक्स बॉक्स ब्लर का उपयोग किया जाता है। ब्लर द्वि-रैखिक के बजाय एक अण्डाकार ढाल है।

नेत्रहीन, यह बड़ी छवियों पर सबसे अच्छा काम करता है। एक गहरा, grungier विषय है। मैं इस बात से खुश हूं कि कैसे उचित रूप से आकार की छवियों पर धब्बा निकला, यह "शुरू होता है" जहां यह शुरू करने के लिए काफी क्रमिक और कठिन है।

पूर्णांक या युगल (एचएसवी के लिए) की सरणियों पर की गई सभी संगणनाएँ।

तर्क के रूप में फ़ाइल पथ की अपेक्षा करता है, प्रत्यय "miniaturized.png" के साथ एक ही स्थान पर फ़ाइल आउटपुट करता है। तत्काल देखने के लिए JFrame में इनपुट और आउटपुट भी प्रदर्शित करता है।

(बड़े संस्करण देखने के लिए क्लिक करें, वे बेहतर तरीके से हैं)

पहले:

बाद:

मुझे कुछ बेहतर टोन मैपिंग या लूमा परिरक्षण जोड़ना पड़ सकता है, क्योंकि यह काफी अंधेरा हो सकता है:

पहले:

बाद:

हालांकि अभी भी दिलचस्प है, इसे पूरे नए माहौल में रखता है।

कोड:

import java.awt.*;
import java.awt.image.*;
import java.io.*;

import javax.imageio.*;
import javax.swing.*;

public class SceneMinifier {

    static final double CONTRAST_INCREASE = 8;
    static final double SATURATION_INCREASE = 7;

    public static void main(String[] args) throws IOException {

        if (args.length < 1) {
            System.out.println("Please specify an input image file.");
            return;
        }

        BufferedImage temp = ImageIO.read(new File(args[0]));

        BufferedImage input = new BufferedImage(temp.getWidth(), temp.getHeight(), BufferedImage.TYPE_INT_ARGB);
        input.getGraphics().drawImage(temp, 0, 0, null); // just want to guarantee TYPE_ARGB

        int[] pixels = ((DataBufferInt) input.getData().getDataBuffer()).getData();

        // saturation

        double[][] hsv = toHSV(pixels);
        for (int i = 0; i < hsv[1].length; i++)
            hsv[1][i] = Math.min(1, hsv[1][i] * (1 + SATURATION_INCREASE / 10));

        // contrast

        int[][] rgb = toRGB(hsv[0], hsv[1], hsv[2]);

        double c = (100 + CONTRAST_INCREASE) / 100;
        c *= c;

        for (int i = 0; i < pixels.length; i++)
            for (int q = 0; q < 3; q++)
                rgb[q][i] = (int) Math.max(0, Math.min(255, ((rgb[q][i] / 255. - .5) * c + .5) * 255));

        // blur

        int w = input.getWidth();
        int h = input.getHeight();

        int k = 5;
        int kd = 2 * k + 1;
        double dd = 1 / Math.hypot(w / 2, h / 2);

        for (int reps = 0; reps < 5; reps++) {

            int tmp[][] = new int[3][pixels.length];
            int vmin[] = new int[Math.max(w, h)];
            int vmax[] = new int[Math.max(w, h)];

            for (int y = 0, yw = 0, yi = 0; y < h; y++) {
                int[] sum = new int[3];
                for (int i = -k; i <= k; i++) {
                    int ii = yi + Math.min(w - 1, Math.max(i, 0));
                    for (int q = 0; q < 3; q++)
                        sum[q] += rgb[q][ii];
                }
                for (int x = 0; x < w; x++) {

                    int dx = x - w / 2;
                    int dy = y - h / 2;
                    double dist = Math.sqrt(dx * dx + dy * dy) * dd;
                    dist *= dist;

                    for (int q = 0; q < 3; q++)
                        tmp[q][yi] = (int) Math.min(255, sum[q] / kd * dist + rgb[q][yi] * (1 - dist));

                    if (y == 0) {
                        vmin[x] = Math.min(x + k + 1, w - 1);
                        vmax[x] = Math.max(x - k, 0);
                    }

                    int p1 = yw + vmin[x];
                    int p2 = yw + vmax[x];

                    for (int q = 0; q < 3; q++)
                        sum[q] += rgb[q][p1] - rgb[q][p2];
                    yi++;
                }
                yw += w;
            }

            for (int x = 0, yi = 0; x < w; x++) {
                int[] sum = new int[3];
                int yp = -k * w;
                for (int i = -k; i <= k; i++) {
                    yi = Math.max(0, yp) + x;
                    for (int q = 0; q < 3; q++)
                        sum[q] += tmp[q][yi];
                    yp += w;
                }
                yi = x;
                for (int y = 0; y < h; y++) {

                    int dx = x - w / 2;
                    int dy = y - h / 2;
                    double dist = Math.sqrt(dx * dx + dy * dy) * dd;
                    dist *= dist;

                    for (int q = 0; q < 3; q++)
                        rgb[q][yi] = (int) Math.min(255, sum[q] / kd * dist + tmp[q][yi] * (1 - dist));

                    if (x == 0) {
                        vmin[y] = Math.min(y + k + 1, h - 1) * w;
                        vmax[y] = Math.max(y - k, 0) * w;
                    }
                    int p1 = x + vmin[y];
                    int p2 = x + vmax[y];

                    for (int q = 0; q < 3; q++)
                        sum[q] += tmp[q][p1] - tmp[q][p2];

                    yi += w;
                }
            }
        }

        // pseudo-lighting pass

        for (int i = 0; i < pixels.length; i++) {
            int dx = i % w - w / 2;
            int dy = i / w - h / 2;
            double dist = Math.sqrt(dx * dx + dy * dy) * dd;
            dist *= dist;

            for (int q = 0; q < 3; q++) {
                if (dist > 1 - .375)
                    rgb[q][i] *= 1 + (Math.sqrt((1 - dist + .125) / 2) - (1 - dist) - .125) * .7;
                if (dist < .375 || dist > .375)
                    rgb[q][i] *= 1 + (Math.sqrt((dist + .125) / 2) - dist - .125) * dist > .375 ? 1 : .8;
                rgb[q][i] = Math.min(255, Math.max(0, rgb[q][i]));
            }
        }

        // reassemble image

        BufferedImage output = new BufferedImage(input.getWidth(), input.getHeight(), BufferedImage.TYPE_INT_ARGB);

        pixels = ((DataBufferInt) output.getData().getDataBuffer()).getData();

        for (int i = 0; i < pixels.length; i++)
            pixels[i] = 255 << 24 | rgb[0][i] << 16 | rgb[1][i] << 8 | rgb[2][i];

        output.setRGB(0, 0, output.getWidth(), output.getHeight(), pixels, 0, output.getWidth());

        // display results

        display(input, output);

        // output image

        ImageIO.write(output, "PNG", new File(args[0].substring(0, args[0].lastIndexOf('.')) + " miniaturized.png"));

    }

    private static int[][] toRGB(double[] h, double[] s, double[] v) {
        int[] r = new int[h.length];
        int[] g = new int[h.length];
        int[] b = new int[h.length];

        for (int i = 0; i < h.length; i++) {
            double C = v[i] * s[i];
            double H = h[i];
            double X = C * (1 - Math.abs(H % 2 - 1));

            double ri = 0, gi = 0, bi = 0;

            if (0 <= H && H < 1) {
                ri = C;
                gi = X;
            } else if (1 <= H && H < 2) {
                ri = X;
                gi = C;
            } else if (2 <= H && H < 3) {
                gi = C;
                bi = X;
            } else if (3 <= H && H < 4) {
                gi = X;
                bi = C;
            } else if (4 <= H && H < 5) {
                ri = X;
                bi = C;
            } else if (5 <= H && H < 6) {
                ri = C;
                bi = X;
            }

            double m = v[i] - C;

            r[i] = (int) ((ri + m) * 255);
            g[i] = (int) ((gi + m) * 255);
            b[i] = (int) ((bi + m) * 255);
        }

        return new int[][] { r, g, b };
    }

    private static double[][] toHSV(int[] c) {
        double[] h = new double[c.length];
        double[] s = new double[c.length];
        double[] v = new double[c.length];

        for (int i = 0; i < c.length; i++) {
            double r = (c[i] & 0xFF0000) >> 16;
            double g = (c[i] & 0xFF00) >> 8;
            double b = c[i] & 0xFF;

            r /= 255;
            g /= 255;
            b /= 255;

            double M = Math.max(Math.max(r, g), b);
            double m = Math.min(Math.min(r, g), b);
            double C = M - m;

            double H = 0;

            if (C == 0)
                H = 0;
            else if (M == r)
                H = (g - b) / C % 6;
            else if (M == g)
                H = (b - r) / C + 2;
            else if (M == b)
                H = (r - g) / C + 4;

            h[i] = H;
            s[i] = C / M;
            v[i] = M;
        }
        return new double[][] { h, s, v };
    }

    private static void display(final BufferedImage original, final BufferedImage output) {

        Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
        int wt = original.getWidth();
        int ht = original.getHeight();
        double ratio = (double) wt / ht;
        if (ratio > 1 && wt > d.width / 2) {
            wt = d.width / 2;
            ht = (int) (wt / ratio);
        }
        if (ratio < 1 && ht > d.getHeight() / 2) {
            ht = d.height / 2;
            wt = (int) (ht * ratio);
        }

        final int w = wt, h = ht;

        JFrame frame = new JFrame();
        JPanel pan = new JPanel() {
            BufferedImage buffer = new BufferedImage(w * 2, h, BufferedImage.TYPE_INT_RGB);
            Graphics2D gg = buffer.createGraphics();

            {
                gg.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
                gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            }

            @Override
            public void paint(Graphics g) {
                gg.drawImage(original, 0, 0, w, h, null);
                gg.drawImage(output, w, 0, w, h, null);
                g.drawImage(buffer, 0, 0, null);
            }
        };
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        pan.setPreferredSize(new Dimension(w * 2, h));
        frame.setLayout(new BorderLayout());
        frame.add(pan, BorderLayout.CENTER);
        frame.pack();
        frame.setVisible(true);
    }
}

Answer 4

जम्मू

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

गाऊसी धब्बा करने के बाद, मैंने छवि को क्षैतिज रूप से 5 क्षेत्रों में विभाजित किया। ऊपर और नीचे के क्षेत्रों को धब्बा का 100% प्राप्त होगा। मध्य क्षेत्र को धब्बा का 0% प्राप्त होगा। शेष दो क्षेत्र 0% से 100% तक व्युत्क्रम घन के अनुपात में होंगे।

कोड का उपयोग J में एक स्क्रिप्ट के रूप में किया जाना है और वह स्क्रिप्ट उसी फ़ोल्डर में input.bmpहोगी जिसमें इनपुट छवि होगी। यह बनाएगा output.bmpजो इनपुट का एक नकली लघु होगा ।

प्रदर्शन अच्छा है और मेरे पीसी पर एक i7-4770k का उपयोग करते हुए, ओपी के सेट से एक छवि को संसाधित करने में लगभग 20 सेकंड लगते हैं। पहले, ;._3सबर्रे ऑपरेटर के साथ मानक कनवल्शन का उपयोग करके एक छवि को संसाधित करने में लगभग 70 सेकंड लगते थे । एफएफटी का उपयोग करके प्रदर्शन को सुधारने के लिए प्रदर्शन में सुधार किया गया था।

इस कोड को bmpऔर math/fftwऐडऑन को इंस्टॉल करने की आवश्यकता होती है। आप का उपयोग कर उन्हें स्थापित कर सकते हैं install 'bmp'और install 'math/fftw'। आपके सिस्टम को fftwलाइब्रेरी स्थापित करने की भी आवश्यकता हो सकती है।

load 'bmp math/fftw'

NB. Define 2d FFT
fft2d =: 4 : 0
  s =. $ y
  i =. zzero_jfftw_ + , y
  o =. 0 * i
  p =. createplan_jfftw_ s;i;o;x;FFTW_ESTIMATE_jfftw_
  fftwexecute_jfftw_ p
  destroyplan_jfftw_ p
  r =. s $ o
  if. x = FFTW_BACKWARD_jfftw_ do.
    r =. r % */ s
  end.
  r
)

fft2 =: (FFTW_FORWARD_jfftw_ & fft2d) :. (FFTW_BACKWARD_jfftw & fft2d)
ifft2 =: (FFTW_BACKWARD_jfftw_ & fft2d) :. (FFTW_FORWARD_jfftw & fft2d)

NB. Settings: Blur radius - Saturation - Contrast
br =: 15
s =: 3
c =: 1.5

NB. Read image and extract rgb channels
i =: 255 %~ 256 | (readbmp 'input.bmp') <.@%"_ 0 ] 2 ^ 16 8 0
'h w' =: }. $ i

NB. Pad each channel to fit Gaussian blur kernel
'hp wp' =: (+: br) + }. $ i
ip =: (hp {. wp {."1 ])"_1 i

NB. Gaussian matrix verb
gm =: 3 : '(%+/@,)s%~2p1%~^(s=.*:-:y)%~-:-+&*:/~i:y'

NB. Create a Gaussian blur kernel
gk =: fft2 hp {. wp {."1 gm br

NB. Blur each channel using FFT-based convolution and unpad
ib =: (9 o. (-br) }. (-br) }."1 br }. br }."1 [: ifft2 gk * fft2)"_1 ip

NB. Create the blur gradient to emulate tilt-shift
m =: |: (w , h) $ h ({. >. (({.~ -)~ |.)) , 1 ,: |. (%~i.) 0.2 I.~ (%~i.) h

NB. Tilt-shift each channel
it =: i ((m * ]) + (-. m) * [)"_1 ib

NB. Create the saturation matrix
sm =: |: ((+ ] * [: =@i. 3:)~ 3 3 |:@$ 0.299 0.587 0.114 * -.) s

NB. Saturate and clamp
its =: 0 >. 1 <. sm +/ .*"1 _ it

NB. Contrast and clamp
itsc =: 0 >. 1 <. 0.5 + c * its - 0.5

NB. Output the image
'output.bmp' writebmp~ (2 <.@^ 16 8 0) +/ .* 255 <.@* itsc

exit ''