एक छवि पर औसत बल

Question

एक प्रोग्राम लिखें जो एक मानक ट्रुकरोलर इमेज और एक 24-बिट आरजीबी रंग (0 से 255 तक तीन संख्या) में लेता है । इनपुट छवि को संशोधित करें (या समान आयामों के साथ एक नई छवि आउटपुट करें) जैसे कि इसका औसत रंग बिल्कुल एकल रंग है जो इनपुट था। आप इसे प्राप्त करने के लिए किसी भी तरह से इनपुट छवि में पिक्सेल को संशोधित कर सकते हैं, लेकिन लक्ष्य रंग परिवर्तन को दृष्टिगत रूप से संभव नहीं बनाना है ।

औसत रंग एक आरजीबी छवि के वास्तव में तीन का एक सेट है गणित का मतलब , प्रत्येक रंग चैनल के लिए एक। औसत लाल मान, कुल पिक्सेल (गोल छवि क्षेत्र) द्वारा विभाजित छवि में सभी पिक्सेल में लाल मानों का योग है, जो निकटतम पूर्णांक तक गोल है। हरे और नीले औसत की गणना एक ही तरीके से की जाती है।

यह पायथन 2 ( पीआईएल के साथ ) स्क्रिप्ट अधिकांश छवि फ़ाइल स्वरूपों के औसत रंग की गणना कर सकती है:

from PIL import Image
print 'Enter image file'
im = Image.open(raw_input()).convert('RGB')
pixels = im.load()
avg = [0, 0, 0]
for x in range(im.size[0]):
    for y in range(im.size[1]):
        for i in range(3):
            avg[i] += pixels[x, y][i]
print 'The average color is', tuple(c // (im.size[0] * im.size[1]) for c in avg)

^{(यहां भी इसी तरह के औसत रंग कार्यक्रम हैं , लेकिन वे ठीक उसी तरह की गणना नहीं करते हैं।)}

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

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

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

परीक्षण छवियाँ

कुछ छवियों और उनके डिफ़ॉल्ट औसत रंगों के साथ खेलने के लिए। पूर्ण आकार के लिए क्लिक करें।

A. औसत (127, 127, 127)

^{से fejesjoco के सभी रंगों के साथ चित्र का जवाब । अपने ब्लॉग पर मूल पाया ।}

बी। औसत (62, 71, 73)

^{योकोहामा । Geobits द्वारा प्रदान किया गया ।}

C. औसत (115, 112, 111)

^{टोक्यो । Geobits द्वारा प्रदान किया गया ।}

डी। औसत (154, 151, 154)

^{एस्चर का झरना । मूल ।}

ई। औसत (105, 103, 102)

^{शास्ता पर्वत । मेरे द्वारा प्रदान किया गया।}

एफ। औसत (75, 91, 110)

^{तारामय रात}

टिप्पणियाँ

• आपके प्रोग्राम का उपयोग करने वाले सटीक इनपुट और आउटपुट प्रारूप और छवि फ़ाइल प्रकार बहुत मायने नहीं रखते हैं। बस यह सुनिश्चित करें कि यह स्पष्ट है कि अपने कार्यक्रम का उपयोग कैसे करें।
• यह शायद एक अच्छा विचार है (लेकिन तकनीकी रूप से एक आवश्यकता नहीं है) कि अगर एक छवि में पहले से ही लक्ष्य औसत रंग है, तो इसे आउटपुट होना चाहिए।
• कृपया औसत रंग इनपुट (150, 100, 100) या (75, 91, 110) के साथ परीक्षण छवियों को पोस्ट करें, ताकि मतदाता अलग-अलग समाधानों में एक ही इनपुट देख सकें। (इससे अधिक उदाहरण पोस्ट करना ठीक है, यहां तक ​​कि प्रोत्साहित भी किया गया।)

Comments

प्रतिभागियों को अपने समाधान की प्रभावशीलता को प्रदर्शित करने के लिए उपयोग किए जाने वाले इनपुट रंगों को चुनना पड़ता है? क्या लोगों के लिए समाधानों की तुलना करना कठिन नहीं है? चरम मामले में, कोई व्यक्ति इनपुट रंगों को चुन सकता है जो छवि के औसत के समान हैं, और ऐसा लगेगा कि उनका समाधान बहुत प्रभावी है।

— रेटो कोराडी

@ vihan1086 अगर मैंने सही ढंग से समझा है, तो औसत रंग एक 24 बिट आरजीबी रंग इनपुट के रूप में प्रदान किया जाता है, इनपुट छवि से नहीं मिला।

— ट्राइकोप्लाक्स

@ Vi101086 की व्याख्या का उपयोग करना दिलचस्प हो सकता है, और उदाहरण चित्रों का उपयोग इनपुट रंगों के स्रोत के रूप में किया जा सकता है ताकि एक छवि दूसरे के औसत रंग में प्रदर्शित हो। इस तरह विभिन्न उत्तरों की तुलना निष्पक्ष रूप से की जा सकती है।

— ट्राइकोप्लाक्स

उनमें से मुख्य समस्या उनमें से ज्यादातर का औसत है जो ग्रे के बहुत करीब है। Starry Night शायद उसी में से सबसे तेज़ है, लेकिन बाकी का औसत बहुत सपाट है।

— जोब

@RetoKoradi उम्मीद है कि मतदाता इस तरह की बातों को ध्यान में रखने के लिए पर्याप्त स्मार्ट होंगे, हालांकि मैंने एक नोट जोड़ा है कि क्या डिफ़ॉल्ट औसत रंगों का उपयोग करना है।

— केल्विन के शौक

Answer 1

पायथन 2 + पीआईएल, साधारण रंग स्केलिंग

from PIL import Image
import math

INFILE = "street.jpg"
OUTFILE = "output.png"
AVERAGE = (150, 100, 100)

im = Image.open(INFILE)
im = im.convert("RGB")
width, height = prev_size = im.size
pixels = {(x, y): list(im.getpixel((x, y)))
          for x in range(width) for y in range(height)}

def get_avg():
    total_rgb = [0, 0, 0]

    for x in range(width):
        for y in range(height):
            for i in range(3):
                total_rgb[i] += int(pixels[x, y][i])

    return [float(x)/(width*height) for x in total_rgb]

curr_avg = get_avg()

while tuple(int(x) for x in curr_avg) != AVERAGE:
    print curr_avg   
    non_capped = [0, 0, 0]
    total_rgb = [0, 0, 0]

    for x in range(width):
        for y in range(height):
            for i in range(3):
                if curr_avg[i] < AVERAGE[i] and pixels[x, y][i] < 255:
                    non_capped[i] += 1
                    total_rgb[i] += int(pixels[x, y][i])

                elif curr_avg[i] > AVERAGE[i] and pixels[x, y][i] > 0:
                    non_capped[i] += 1
                    total_rgb[i] += int(pixels[x, y][i])

    ratios = [1 if z == 0 else
              x/(y/float(z))
              for x,y,z in zip(AVERAGE, total_rgb, non_capped)]

    for x in range(width):
        for y in range(height):
            col = []

            for i in range(3):
                new_col = (pixels[x, y][i] + 0.01) * ratios[i]
                col.append(min(255, max(0, new_col)))

            pixels[x, y] = tuple(col)

    curr_avg = get_avg()

print curr_avg

for pixel in pixels:
    im.putpixel(pixel, tuple(int(x) for x in pixels[pixel]))

im.save(OUTFILE)

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

• स्केलिंग 0 अभी भी 0 में परिणाम देता है, इसलिए इससे पहले कि हम पैमाने पर हम कुछ छोटा जोड़ें (यहां 0.01)

• RGB मान 0 और 255 के बीच होते हैं, इसलिए हमें इस तथ्य के लिए अनुपात को समायोजित करने की आवश्यकता है कि छायांकित पिक्सेल स्केलिंग कुछ भी नहीं करता है।

चित्र PNG के रूप में सहेजते हैं क्योंकि JPG के रूप में सहेजने से रंग औसत गड़बड़ हो जाता है।

नमूना उत्पादन

(40, 40, 40)

(150, 100, 100)

(75, 91, 110), स्टारट्री नाइट पैलेट

Comments

आप निश्चित रूप से इसके लिए गैर-हानिपूर्ण संपीड़न के साथ एक छवि प्रारूप का उपयोग करना चाहते हैं। इसलिए JPEG एक अच्छा विकल्प नहीं है।

— रेटो कोरदी

आप हमेशा शांत छवि चुनौती समाधान के लिए Sp पर भरोसा कर सकते हैं।

— एलेक्स ए।

Answer 2

सी ++, गामा सुधार

यह एक साधारण गामा सुधार का उपयोग करके छवि का एक चमक समायोजन करता है, लक्ष्य घटक से मेल खाने के लिए प्रत्येक घटक के लिए अलग से निर्धारित गामा मूल्य के साथ।

उच्च स्तरीय कदम हैं:

1. प्रत्येक रंग घटक के लिए चित्र पढ़ें और हिस्टोग्राम निकालें।
2. प्रत्येक घटक के लिए गामा मान की एक द्विआधारी खोज करें। गामा मूल्यों पर एक द्विआधारी खोज की जाती है, जब तक कि परिणामस्वरूप हिस्टोग्राम में वांछित औसत न हो।
3. छवि को दूसरी बार पढ़ें, और गामा सुधार लागू करें।

सभी छवि इनपुट / आउटपुट ASCII में PPM फ़ाइलों का उपयोग करते हैं। GIMP का उपयोग करके छवियाँ / से PNG में परिवर्तित कर दी गईं। कोड मैक पर चलाया गया था, विंडोज पर छवि रूपांतरण किए गए थे।

कोड:

#include <cmath>
#include <string>
#include <vector>
#include <sstream>
#include <fstream>
#include <iostream>

static inline int mapVal(int val, float gamma)
{
    float relVal = (val + 1.0f) / 257.0f;
    float newRelVal = powf(relVal, gamma);

    int newVal = static_cast<int>(newRelVal * 257.0f - 0.5f);
    if (newVal < 0)
    {
        newVal = 0;
    }
    else if (newVal > 255)
    {
        newVal = 255;
    }

    return newVal;
}

struct Histogram
{
    Histogram();

    bool read(const std::string fileName);
    int getAvg(int colIdx) const;
    void adjust(const Histogram& origHist, int colIdx, float gamma);

    int pixCount;
    std::vector<int> freqA[3];
};

Histogram::Histogram()
  : pixCount(0)
{
    for (int iCol = 0; iCol < 3; ++iCol)
    {
        freqA[iCol].resize(256, 0);
    }
}

bool Histogram::read(const std::string fileName)
{
    for (int iCol = 0; iCol < 3; ++iCol)
    {
        freqA[iCol].assign(256, 0);
    }

    std::ifstream inStrm(fileName);

    std::string format;
    inStrm >> format;
    if (format != "P3")
    {
        std::cerr << "invalid PPM header" << std::endl;
        return false;
    }

    int w = 0, h = 0;
    inStrm >> w >> h;
    if (w <= 0 || h <= 0)
    {
        std::cerr << "invalid size" << std::endl;
        return false;
    }

    int maxVal = 0;
    inStrm >> maxVal;
    if (maxVal != 255)
    {
        std::cerr << "invalid max value (255 expected)" << std::endl;
        return false;
    }

    pixCount = w * h;

    int sumR = 0, sumG = 0, sumB = 0;
    for (int iPix = 0; iPix < pixCount; ++iPix)
    {
        int r = 0, g = 0, b = 0;
        inStrm >> r >> g >> b;
        ++freqA[0][r];
        ++freqA[1][g];
        ++freqA[2][b];
    }

    return true;
}

int Histogram::getAvg(int colIdx) const
{
    int avg = 0;
    for (int val = 0; val < 256; ++val)
    {
        avg += freqA[colIdx][val] * val;
    }

    return avg / pixCount;
}

void Histogram::adjust(const Histogram& origHist, int colIdx, float gamma)
{
    freqA[colIdx].assign(256, 0);

    for (int val = 0; val < 256; ++val)
    {
        int newVal = mapVal(val, gamma);
        freqA[colIdx][newVal] += origHist.freqA[colIdx][val];
    }
}

void mapImage(const std::string fileName, float gammaA[])
{
    std::ifstream inStrm(fileName);

    std::string format;
    inStrm >> format;

    int w = 0, h = 0;
    inStrm >> w >> h;

    int maxVal = 0;
    inStrm >> maxVal;

    std::cout << "P3" << std::endl;
    std::cout << w << " " << h << std::endl;
    std::cout << "255" << std::endl;

    int nPix = w * h;

    for (int iPix = 0; iPix < nPix; ++iPix)
    {
        int inRgb[3] = {0};
        inStrm >> inRgb[0] >> inRgb[1] >> inRgb[2];

        int outRgb[3] = {0};
        for (int iCol = 0; iCol < 3; ++iCol)
        {
            outRgb[iCol] = mapVal(inRgb[iCol], gammaA[iCol]);
        }

        std::cout << outRgb[0] << " " << outRgb[1] << " "
                  << outRgb[2] << std::endl;
    }
}

int main(int argc, char* argv[])
{
    if (argc < 5)
    {
        std::cerr << "usage: " << argv[0]
                  << " ppmFileName targetR targetG targetB"
                  << std::endl;
        return 1;
    }

    std::string inFileName = argv[1];

    int targAvg[3] = {0};
    std::istringstream strmR(argv[2]);
    strmR >> targAvg[0];
    std::istringstream strmG(argv[3]);
    strmG >> targAvg[1];
    std::istringstream strmB(argv[4]);
    strmB >> targAvg[2];

    Histogram origHist;
    if (!origHist.read(inFileName))
    {
        return 1;
    }

    Histogram newHist(origHist);
    float gammaA[3] = {0.0f};

    for (int iCol = 0; iCol < 3; ++iCol)
    {
        float minGamma = 0.0f;
        float maxGamma = 1.0f;
        for (;;)
        {
            newHist.adjust(origHist, iCol, maxGamma);
            int avg = newHist.getAvg(iCol);
            if (avg <= targAvg[iCol])
            {
                break;
            }
            maxGamma *= 2.0f;
        }

        for (;;)
        {
            float midGamma = 0.5f * (minGamma + maxGamma);

            newHist.adjust(origHist, iCol, midGamma);
            int avg = newHist.getAvg(iCol);
            if (avg < targAvg[iCol])
            {
                maxGamma = midGamma;
            }
            else if (avg > targAvg[iCol])
            {
                minGamma = midGamma;
            }
            else
            {
                gammaA[iCol] = midGamma;
                break;
            }
        }
    }

    mapImage(inFileName, gammaA);

    return 0;
}

कोड अपने आप में काफी सीधा है। एक सूक्ष्म लेकिन महत्वपूर्ण विवरण यह है कि, जबकि रंग मान रेंज [0, 255] में हैं, मैं उन्हें गामा वक्र में मैप करता हूं जैसे कि रेंज [-1, 256] थे। यह औसत को 0 या 255 के लिए मजबूर करने की अनुमति देता है। अन्यथा, 0 हमेशा 0 ही रहेगा, और 255 हमेशा 255 रहेगा, जो कि 0/255 के औसत के लिए कभी भी अनुमति नहीं दे सकता है।

काम में लाना:

1. एक्सटेंशन वाली फाइल में कोड सेव करें .cpp, जैसे force.cpp।
2. के साथ संकलित करें c++ -o force -O2 force.cpp।
3. साथ चलाना ./force input.ppm targetR targetG target >output.ppm।

40, 40, 40 के लिए नमूना उत्पादन

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

150, 100, 100 के लिए नमूना उत्पादन:

75, 91, 110 के लिए नमूना उत्पादन:

Comments

मुझे सीमा को पूरा करने के लिए अन्य छवियों को छोटा करना पड़ा - शायद यह कोशिश करें?

— Sp3000

@ Sp3000 ठीक है, अब सभी छवियों को शामिल किया गया। इसके अलावा अब थंबनेल के साथ। मैंने बड़े लोगों के लिए जेपीईजी संस्करण का उपयोग करके समाप्त किया। वास्तव में, उनमें से एक आकार सीमा से नीचे था, लेकिन ऐसा लग रहा है कि इसे जेपीईजी में ऑटो-कन्वर्ट किया गया था। पहले और आखिरी उदाहरण अभी भी पीएनजी हैं।

— रेटो कोराडी

Answer 3

अजगर 2 + पीआईएल

from PIL import Image
import random
import math

SOURCE = 'input.png'
OUTPUT = 'output.png'
AVERAGE = [150, 100, 100]

im = Image.open(SOURCE).convert('RGB')
pixels = im.load()
w = im.size[0]
h = im.size[1]
npixels = w * h

maxdiff = 0.1

# for consistent results...
random.seed(42)
order = range(npixels)
random.shuffle(order)

def calc_sum(pixels, w, h):
    sums = [0, 0, 0]
    for x in range(w):
        for y in range(h):
            for i in range(3):
                sums[i] += pixels[x, y][i]
    return sums

def get_coordinates(index, w):
    return tuple([index % w, index // w])

desired_sums = [AVERAGE[0] * npixels, AVERAGE[1] * npixels, AVERAGE[2] * npixels]

sums = calc_sum(pixels, w, h)
for i in range(3):
    while sums[i] != desired_sums[i]:
        for j in range(npixels):
            if sums[i] == desired_sums[i]:
                break
            elif sums[i] < desired_sums[i]:
                coord = get_coordinates(order[j], w)
                pixel = list(pixels[coord])
                delta = int(maxdiff * (255 - pixel[i]))
                if delta == 0 and pixel[i] != 255:
                    delta = 1
                delta = min(delta, desired_sums[i] - sums[i])

                sums[i] += delta
                pixel[i] += delta
                pixels[coord] = tuple(pixel)
            else:
                coord = get_coordinates(order[j], w)
                pixel = list(pixels[coord])
                delta = int(maxdiff * pixel[i])
                if delta == 0 and pixel[i] != 0:
                    delta = 1
                delta = min(delta, sums[i] - desired_sums[i])

                sums[i] -= delta
                pixel[i] -= delta
                pixels[coord] = tuple(pixel)

# output image
for x in range(w):
    for y in range(h):
        im.putpixel(tuple([x, y]), pixels[tuple([x, y])])

im.save(OUTPUT)

यह प्रत्येक पिक्सेल को यादृच्छिक क्रम में पुनरावृत्त करता है, और पिक्सेल के रंग के प्रत्येक घटक के बीच की दूरी को कम करता है और 2550 ( या वर्तमान औसत वांछित औसत से कम या अधिक है पर निर्भर करता है) के करता है। एक निश्चित गुणन कारक द्वारा दूरी को कम किया जाता है। वांछित औसत प्राप्त होने तक यह दोहराया जाता है। कमी हमेशा कम से कम होती है 1, जब तक कि रंग यह नहीं होता 255(या 0), यह सुनिश्चित करने के लिए कि पिक्सेल सफेद या काले रंग के करीब होने पर प्रसंस्करण स्टाल नहीं होता है।

नमूना उत्पादन

(40, 40, 40)

(150, 100, 100)

(75, 91, 110)

Answer 4

जावा

एक आरएनजी आधारित दृष्टिकोण। बड़ी इनपुट छवियों के लिए थोड़ा धीमा।

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.*;

import javax.imageio.ImageIO;


public class Averager {
    static Random r;
    static long sigmaR=0,sigmaG=0,sigmaB=0;
    static int w,h;
    static int rbar,gbar,bbar;
    static BufferedImage i;
    private static File file;
    static void upRed(){
        int x=r.nextInt(w);
        int y=r.nextInt(h);
        Color c=new Color(i.getRGB(x, y));
        if(c.getRed()==255)return;
        sigmaR++;
        c=new Color(c.getRed()+1,c.getGreen(),c.getBlue());
        i.setRGB(x, y,c.getRGB());
    }
    static void downRed(){
        int x=r.nextInt(w);
        int y=r.nextInt(h);
        Color c=new Color(i.getRGB(x, y));
        if(c.getRed()==0)return;
        sigmaR--;
        c=new Color(c.getRed()-1,c.getGreen(),c.getBlue());
        i.setRGB(x, y,c.getRGB());
    }
    static void upGreen(){
        int x=r.nextInt(w);
        int y=r.nextInt(h);
        Color c=new Color(i.getRGB(x, y));
        if(c.getGreen()==255)return;
        sigmaG++;
        c=new Color(c.getRed(),c.getGreen()+1,c.getBlue());
        i.setRGB(x, y,c.getRGB());
    }
    static void downGreen(){
        int x=r.nextInt(w);
        int y=r.nextInt(h);
        Color c=new Color(i.getRGB(x, y));
        if(c.getGreen()==0)return;
        sigmaG--;
        c=new Color(c.getRed(),c.getGreen()-1,c.getBlue());
        i.setRGB(x,y,c.getRGB());
    }
    static void upBlue(){
        int x=r.nextInt(w);
        int y=r.nextInt(h);
        Color c=new Color(i.getRGB(x, y));
        if(c.getBlue()==255)return;
        sigmaB++;
        c=new Color(c.getRed(),c.getGreen(),c.getBlue()+1);
        i.setRGB(x, y,c.getRGB());
    }
    static void downBlue(){
        int x=r.nextInt(w);
        int y=r.nextInt(h);
        Color c=new Color(i.getRGB(x, y));
        if(c.getBlue()==0)return;
        sigmaB--;
        c=new Color(c.getRed(),c.getGreen(),c.getBlue()-1);
        i.setRGB(x,y,c.getRGB());
    }
    public static void main(String[]a) throws Exception{
        Scanner in=new Scanner(System.in);
        i=ImageIO.read(file=new File(in.nextLine()));
        rbar=in.nextInt();
        gbar=in.nextInt();
        bbar=in.nextInt();
        w=i.getWidth();
        h=i.getHeight();
        final int npix=w*h;
        r=new Random(npix*(long)i.hashCode());
        for(int x=0;x<w;x++){
            for(int y=0;y<h;y++){
                Color c=new Color(i.getRGB(x, y));
                sigmaR+=c.getRed();
                sigmaG+=c.getGreen();
                sigmaB+=c.getBlue();
            }
        }
        while(sigmaR/npix<rbar){
            upRed();
        }
        while(sigmaR/npix>rbar){
            downRed();
        }
        while(sigmaG/npix<gbar){
            upGreen();
        }
        while(sigmaG/npix>gbar){
            downGreen();
        }
        while(sigmaB/npix<bbar){
            upBlue();
        }
        while(sigmaB/npix>bbar){
            downBlue();
        }
        String k=file.getName().split("\\.")[0];
        ImageIO.write(i,"png",new File(k="out_"+k+".png"));
    }
}

टेस्ट:

(40,40,40)

(150,100,100)

(75,91,110)