একটি চিত্র উপর একটি গড় জোর

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), কোনও ইনপুট চিত্র পুরোপুরি কালো করা দরকার কারণ যদি কোনও পিক্সেলের শূন্য-না মান থাকে, তবে এটিও গড় অ-শূন্য করে তোলে ( রাউন্ড-অফ ত্রুটিগুলি বাদ দেওয়া)। ভোট দেওয়ার সময় এ জাতীয় সীমাবদ্ধতাগুলি মনে রাখবেন।

চিত্র পরীক্ষা করুন

কিছু চিত্র এবং এগুলির চারপাশে খেলতে তাদের ডিফল্ট গড় রঙ। পূর্ণ মাপের জন্য ক্লিক করুন।

উঃ গড় (127, 127, 127)

^{থেকে fejesjoco এর সব রং দিয়ে ছবি উত্তর । পাওয়া মূল উপর তার ব্লগে ।}

বি গড় (62, 71, 73)

^{যোকোহামা । দ্বারা প্রদান করা Geobits ।}

সি গড় (115, 112, 111)

^{টোকিও । দ্বারা প্রদান করা Geobits ।}

ডি গড় (154, 151, 154)

^{Escher এর জলপ্রপাত । আসল ।}

ই গড় (105, 103, 102)

^{মাষ্ট শাস্তা । আমার দ্বারা সরবরাহ করা।}

এফ গড় (75, 91, 110)

^{তারকাময় রাত}

মন্তব্য

• আপনার প্রোগ্রামটি যে সঠিক ইনপুট এবং আউটপুট ফর্ম্যাট এবং ইমেজ ফাইলের ধরণের ব্যবহার করে সেগুলি তেমন গুরুত্বপূর্ণ নয়। আপনার প্রোগ্রামটি কীভাবে ব্যবহার করবেন তা নিশ্চিত হয়ে নিন।
• এটি সম্ভবত একটি ভাল ধারণা (তবে প্রযুক্তিগতভাবে কোনও প্রয়োজন নয়) যে কোনও চিত্রের যদি ইতিমধ্যে লক্ষ্য গড় রঙ থাকে তবে তা যেমন হয় আউটপুটও হওয়া উচিত।
• গড় রঙ ইনপুট সহ পরীক্ষার চিত্রগুলি পোস্ট করুন (১৫০, ১০০, ১০০) অথবা (75, 91, 110), যাতে ভোটাররা বিভিন্ন সমাধানগুলিতে একই ইনপুট দেখতে পান। (এর চেয়ে বেশি উদাহরণ পোস্ট করা ভাল, এমনকি উত্সাহিতও।)

Comments

অংশগ্রহণকারীরা তাদের সমাধানটির কার্যকারিতা প্রদর্শনের জন্য যে ইনপুট রঙগুলি ব্যবহার করেন তা চয়ন করতে পারেন? এর ফলে লোকেরা সমাধানগুলির তুলনা করতে অসুবিধা হয় না? চরম ক্ষেত্রে, কেউ ইনপুট রঙগুলি চয়ন করতে পারে যা চিত্রের গড়ের সাথে খুব মিলে যায় এবং এটির সমাধানটি খুব কার্যকর বলে মনে হয়।

— রেটো কোরাাদি

@ vihan1086 যদি আমি সঠিকভাবে বুঝতে পারি তবে গড় রঙটি 24 বিট আরজিবি রঙিন ইনপুট হিসাবে সরবরাহ করা হয়, কোনও ইনপুট চিত্র থেকে পাওয়া যায় না।

— 23:15

@ Vihan1086 এর ব্যাখ্যাটি ব্যবহার করা আকর্ষণীয় হতে পারে এবং উদাহরণস্বরূপ চিত্রগুলি ইনপুট রঙের উত্স হিসাবে ব্যবহার করুন যাতে একটি চিত্র অন্যটির গড় রঙে প্রদর্শিত হয়। এইভাবে বিভিন্ন উত্তরগুলি মোটামুটি তুলনা করা যায়।

— 23:55

এর সাথে মুখ্য সমস্যা হ'ল তাদের বেশিরভাগের গড় খুব ধূসরের কাছাকাছি have স্টেরি নাইট সম্ভবত এটি থেকে খুব দূরের, তবে বাকি গড় বেশ স্পষ্টভাবে বেরিয়েছে।

— জিওবিটস

@ রিটোকোরাডি আশা করি ভোটাররা এই জাতীয় বিষয়গুলি বিবেচনায় নিতে যথেষ্ট স্মার্ট হবেন, যদিও আমি কোন ডিফল্ট গড় রং ব্যবহার করতে পারি তার একটি নোট যোগ করেছি।

— ক্যালভিনের

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)

• আরজিবি মানগুলি 0 থেকে 255 এর মধ্যে থাকে, সুতরাং ক্যা্যাপড পিক্সেল স্কেলিং কোনও কাজ করে না তা নিশ্চিত করার জন্য আমাদের সেই অনুপাতটি সামঞ্জস্য করতে হবে।

চিত্রগুলি পিএনজি হিসাবে সংরক্ষণ করে কারণ জেপিজি হিসাবে সংরক্ষণ করা রঙের গড়পড়তাতে বিশৃঙ্খলা দেখায়।

নমুনা আউটপুট

(40, 40, 40)

(150, 100, 100)

(75, 91, 110), স্টারি নাইট প্যালেট

Comments

আপনি অবশ্যই এটির জন্য অ-ক্ষতিকারক সংকোচনের সাথে একটি চিত্র বিন্যাসটি ব্যবহার করতে চান। সুতরাং জেপিইজি কোনও ভাল বিকল্প নয়।

— রেটো কোরাাদি

শীতল চিত্র চ্যালেঞ্জ সমাধানের জন্য আপনি সবসময় এসপকে গণনা করতে পারেন।

— অ্যালেক্স এ।

Answer 2

সি ++, গামা সংশোধন

লক্ষ্য গেমের সাথে মিল রেখে প্রতিটি উপাদানকে আলাদাভাবে নির্ধারিত গামা মান সহ এটি একটি সাধারণ গামা সংশোধন ব্যবহার করে চিত্রের একটি উজ্জ্বলতা সমন্বয় করে।

উচ্চ স্তরের পদক্ষেপগুলি হ'ল:

1. প্রতিটি রঙের উপাদানগুলির জন্য চিত্র পড়ুন এবং হিস্টোগ্রামটি বের করুন।
2. প্রতিটি উপাদান জন্য গামা মান একটি বাইনারি অনুসন্ধান সম্পাদন। গাইনার মানগুলিতে একটি বাইনারি অনুসন্ধান করা হয়, যতক্ষণ না ফলপ্রাপ্ত হিস্টোগ্রামের পছন্দসই গড় হয়।
3. চিত্রটি দ্বিতীয়বার পড়ুন এবং গামা সংশোধন করুন।

সমস্ত চিত্র ইনপুট / আউটপুট ASCII এ পিপিএম ফাইল ব্যবহার করে। চিত্রগুলি জিআইএমপি ব্যবহার করে / পিএনজি থেকে রূপান্তরিত হয়েছিল। কোডটি একটি ম্যাকটিতে চালানো হয়েছিল, উইন্ডোজটিতে চিত্র রূপান্তর করা হয়েছিল।

কোড:

#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 তে বাধ্য করতে বাধ্য করে Otherwise অন্যথায়, 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 এর জন্য নমুনা আউটপুট

নোট করুন যে সমস্ত বৃহত্তর নমুনার চিত্রগুলি জেপিগ হিসাবে অন্তর্ভুক্ত রয়েছে কারণ সেগুলি পিএনজি হিসাবে এসই আকারের সীমা অতিক্রম করে। যেহেতু জেপিইজি একটি ক্ষতিকারক সংকোচনের ফর্ম্যাট, তাই তারা লক্ষ্যমাত্রার গড়ের সাথে মেলে না। আমার কাছে সমস্ত ফাইলের পিএনজি সংস্করণ রয়েছে, যা ঠিক মেলে।

150, 100, 100 এর জন্য নমুনা আউটপুট:

75, 91, 110 এর জন্য নমুনা আউটপুট:

Comments

সীমাটি পূরণের জন্য আমাকে অন্যান্য চিত্রগুলি সঙ্কুচিত করতে হয়েছিল - সম্ভবত এটি চেষ্টা করবেন?

— Sp3000

@ Sp3000 ঠিক আছে, এখন সমস্ত চিত্র অন্তর্ভুক্ত করা হয়েছে। থাম্বনেইলগুলিও এখন রয়েছে। আমি বড়গুলির জন্য JPEG সংস্করণটি ব্যবহার করে শেষ করেছি। প্রকৃতপক্ষে, তাদের মধ্যে একটি সীমাবদ্ধতার নীচে ছিল তবে দেখে মনে হচ্ছে এটি জেপিইজে স্বয়ংক্রিয়ভাবে রূপান্তরিত হয়েছিল। প্রথম এবং শেষ উদাহরণগুলি এখনও পিএনজি রয়েছে।

— রেটো কোরাাদি

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)

এটি প্রতিটি পিক্সেলের মাধ্যমে এলোমেলো ক্রমে পুনরাবৃত্তি করে এবং পিক্সেলের রঙের প্রতিটি উপাদান এবং 255বা 0(বর্তমান গড় পছন্দসই গড়ের চেয়ে কম বা বেশি কিনা তার উপর নির্ভর করে) এর দূরত্ব হ্রাস করে । দূরত্বটি একটি নির্দিষ্ট গুণক গুণক দ্বারা হ্রাস করা হয়। কাঙ্ক্ষিত গড় প্রাপ্ত না হওয়া পর্যন্ত এটি পুনরাবৃত্তি হয়। পিক্সেলটি সাদা বা কালোয়ের কাছাকাছি হয়ে গেলে প্রসেসিংটি স্টল না হয়ে যায় তা নিশ্চিত করার জন্য 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)