Viết chương trình lấy hình ảnh truecolor tiêu chuẩn và màu RGB 24 bit duy nhất (ba số từ 0 đến 255). Sửa đổi hình ảnh đầu vào (hoặc xuất hình ảnh mới có cùng kích thước) sao cho màu trung bình của nó chính xác là màu duy nhất được nhập. Bạn có thể sửa đổi các pixel trong hình ảnh đầu vào theo bất kỳ cách nào bạn muốn để đạt được điều này, nhưng mục tiêu là làm cho màu sắc thay đổi một cách trực quan không thể nhận thấy nhất có thể .

Các màu trung bình của một hình ảnh RGB thực sự là một tập hợp của ba phương tiện số học , một cho mỗi kênh màu. Giá trị đỏ trung bình là tổng của các giá trị đỏ trên tất cả các pixel trong ảnh chia cho tổng số pixel (vùng hình ảnh), được làm tròn xuống số nguyên gần nhất. Trung bình màu xanh lá cây và màu xanh được tính theo cùng một cách.

Đây Python 2 (với PIL script) có thể tính toán màu trung bình của hầu hết các định dạng file ảnh:

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)

^{(Có các chương trình màu trung bình tương tự ở đây , nhưng chúng không nhất thiết phải thực hiện cùng một phép tính.)}

Yêu cầu chính cho chương trình của bạn là đối với bất kỳ hình ảnh đầu vào nào , màu trung bình của đầu ra tương ứng của nó phải khớp chính xác với màu đã nhập - như được đánh giá bởi đoạn mã Python hoặc một số mã tương đương. Hình ảnh đầu ra cũng phải có cùng kích thước với hình ảnh đầu vào.

Vì vậy, về mặt kỹ thuật, bạn có thể gửi một chương trình chỉ đơn giản là tô màu toàn bộ màu trung bình được chỉ định (vì trung bình sẽ luôn là màu đó), nhưng đây là một cuộc thi phổ biến - bài gửi có số phiếu bầu cao nhất sẽ giành chiến thắng và tầm thường như vậy trình sẽ không giúp bạn có nhiều upvote. Những ý tưởng mới lạ như tận dụng lợi thế của sự kỳ quặc trong tầm nhìn của con người, hoặc thu nhỏ hình ảnh xuống và vẽ một đường viền màu xung quanh nó (hy vọng) sẽ giúp bạn bỏ phiếu.

Lưu ý rằng sự kết hợp nhất định của màu trung bình và hình ảnh đòi hỏi phải thay đổi màu sắc cực kỳ đáng chú ý. Ví dụ: nếu màu trung bình phù hợp là màu đen (0, 0, 0), thì bất kỳ hình ảnh đầu vào nào cũng cần phải được tạo thành màu đen hoàn toàn bởi vì nếu bất kỳ pixel nào có giá trị khác không, chúng cũng sẽ tạo ra giá trị trung bình khác không ( chặn lỗi làm tròn số). Giữ những hạn chế như vậy trong tâm trí khi bỏ phiếu.

Hình ảnh thử nghiệm

Một số hình ảnh và màu trung bình mặc định của chúng để chơi xung quanh. Nhấn vào đây để kích thước đầy đủ.

A. trung bình (127, 127, 127)

^{Từ hình ảnh của fejesjoco với tất cả các màu trả lời . Tìm thấy bản gốc trên blog của mình .}

B. trung bình (62, 71, 73)

^{Yokohama . Được cung cấp bởi Geobits .}

C. trung bình (115, 112, 111)

^{Tokyo . Được cung cấp bởi Geobits .}

D. trung bình (154, 151, 154)

^{Thác nước Escher's . Bản gốc .}

E. trung bình (105, 103, 102)

^{Núi Shasta . Cung cấp bởi tôi.}

F. trung bình (75, 91, 110)

^{Đêm lấp lánh}

Ghi chú

• Các định dạng đầu vào và đầu ra chính xác và các loại tệp hình ảnh mà chương trình của bạn sử dụng không quan trọng lắm. Chỉ cần chắc chắn rằng nó rõ ràng làm thế nào để sử dụng chương trình của bạn.
• Có lẽ là một ý tưởng tốt (nhưng về mặt kỹ thuật không phải là một yêu cầu) rằng nếu một hình ảnh đã có màu trung bình của mục tiêu, thì nó phải là đầu ra.
• Vui lòng đăng hình ảnh thử nghiệm với đầu vào màu trung bình là (150, 100, 100) hoặc (75, 91, 110), để cử tri có thể thấy các đầu vào giống nhau trên các giải pháp khác nhau. (Đăng nhiều ví dụ hơn là tốt, thậm chí được khuyến khích.)

Python 2 + PIL, chia tỷ lệ màu đơn giản

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)

Đây là một cách tiếp cận ngây thơ nên phục vụ như là một cơ sở tốt. Ở mỗi lần lặp, chúng tôi so sánh mức trung bình hiện tại của chúng tôi với mức trung bình mong muốn và chia tỷ lệ RGB của từng pixel theo tỷ lệ theo. Chúng tôi phải cẩn thận một chút, vì hai lý do:

• Chia tỷ lệ 0 vẫn cho kết quả bằng 0, vì vậy trước khi chia tỷ lệ, chúng tôi thêm một số thứ nhỏ (tại đây 0.01)

• Các giá trị RGB nằm trong khoảng từ 0 đến 255, vì vậy chúng ta cần điều chỉnh tỷ lệ phù hợp để bù cho thực tế là các pixel được giới hạn tỷ lệ không làm gì cả.

Hình ảnh lưu dưới dạng PNG vì lưu dưới dạng JPG dường như làm rối trung bình màu.

Sản lượng mẫu

(40, 40, 40)

(150, 100, 100)

(75, 91, 110), bảng màu Starry Night

C ++, hiệu chỉnh gamma

Điều này thực hiện điều chỉnh độ sáng của hình ảnh bằng cách sử dụng hiệu chỉnh gamma đơn giản, với giá trị gamma được xác định riêng cho từng thành phần để phù hợp với mức trung bình của mục tiêu.

Các bước cấp cao là:

1. Đọc hình ảnh và trích xuất biểu đồ cho từng thành phần màu.
2. Thực hiện tìm kiếm nhị phân của giá trị gamma cho từng thành phần. Một tìm kiếm nhị phân được thực hiện trên các giá trị gamma, cho đến khi biểu đồ kết quả có mức trung bình mong muốn.
3. Đọc hình ảnh lần thứ hai và áp dụng hiệu chỉnh gamma.

Tất cả đầu vào / đầu ra hình ảnh sử dụng các tệp PPM trong ASCII. Hình ảnh được chuyển đổi từ / sang PNG bằng GIMP. Mã được chạy trên máy Mac, chuyển đổi hình ảnh được thực hiện trên Windows.

Mã số:

#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;
}

Bản thân mã này khá đơn giản. Một chi tiết tinh tế nhưng quan trọng là, trong khi các giá trị màu nằm trong phạm vi [0, 255], tôi ánh xạ chúng tới đường cong gamma như thể phạm vi là [-1, 256]. Điều này cho phép trung bình bị buộc về 0 hoặc 255. Nếu không, 0 sẽ luôn là 0 và 255 sẽ luôn duy trì 255, điều này có thể không bao giờ cho phép trung bình là 0/255.

Để sử dụng:

1. Lưu mã trong một tệp có phần mở rộng .cpp, ví dụ force.cpp.
2. Biên dịch với c++ -o force -O2 force.cpp.
3. Chạy với ./force input.ppm targetR targetG target >output.ppm.

Sản lượng mẫu cho 40, 40, 40

Lưu ý rằng hình ảnh cho tất cả các mẫu lớn hơn được bao gồm dưới dạng JPEG vì chúng vượt quá giới hạn kích thước SE là PNG. Vì JPEG là định dạng nén mất dữ liệu, chúng có thể không khớp chính xác với trung bình mục tiêu. Tôi có phiên bản PNG của tất cả các tệp, khớp chính xác.

Đầu ra mẫu cho 150, 100, 100:

Đầu ra mẫu cho 75, 91, 110:

Python 2 + PIL

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)

Điều này lặp lại qua từng pixel theo thứ tự ngẫu nhiên và giảm khoảng cách giữa mỗi thành phần màu của pixel và 255hoặc 0(tùy thuộc vào mức trung bình hiện tại nhỏ hơn hoặc lớn hơn mức trung bình mong muốn). Khoảng cách được giảm bởi một yếu tố nhân cố định. Điều này được lặp lại cho đến khi thu được trung bình mong muốn. Việc giảm luôn luôn ít nhất 1, trừ khi màu là 255(hoặc 0), để đảm bảo rằng quá trình xử lý không bị đình trệ một khi pixel gần với màu trắng hoặc đen.

Sản lượng mẫu

(40, 40, 40)

(150, 100, 100)

(75, 91, 110)

Java

Một cách tiếp cận dựa trên RNG. Một chút chậm cho hình ảnh đầu vào lớn.

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"));
    }
}

Các xét nghiệm:

(40,40,40)

(150.100.100)

(75,91,110)