source: www/study/study.py @ 1927 Tweet

#!/usr/bin/env python

import math, gd

# Tiny image class to make examples short and readable
class Image(gd.image):
    def __new__(args, truecolor = False):
        gd.gdMaxColors = 256 * 256 * 256
        if truecolor:
            return gd.image.__new__(args, True)
        else:
            return gd.image.__new__(args)
    def getGray(self, x, y):
        p = self.getPixel((x, y))
        c = self.colorComponents(p)[0] / 255.0
        return c
    def getRgb(self, x, y):
        p = self.getPixel((x, y))
        rgb = self.colorComponents(p)
        return [rgb[0] / 255.0, rgb[1] / 255.0, rgb[2] / 255.0]
    def setGray(self, x, y, t):
        p = (int)(t * 255.999)
        c = self.colorResolve((p, p, p))
        self.setPixel((x, y), c)
    def setRgb(self, x, y, r, g, b):
        r = (int)(r * 255.999)
        g = (int)(g * 255.999)
        b = (int)(b * 255.999)
        c = self.colorResolve((r, g, b))
        self.setPixel((x, y), c)

# Manipulate gamma values
class Gamma:
    def CtoI(x):
        return math.pow(x, 2.2)
    def ItoC(x):
        return math.pow(x, 1 / 2.2)
    CtoI = staticmethod(CtoI)
    ItoC = staticmethod(ItoC)

# Load the 256x256 grayscale Lenna image
lenna256bw = Image("lenna256bw.png")

# Create a 32x256 grayscale gradient
gradient256bw = Image((32, 256))
for x in range(32):
    for y in range(256):
        gradient256bw.setGray(x, 255 - y, y / 255.)

# Output 1: 50% threshold
# Output 2: 40% threshold
# Output 3: 60% threshold
def test1(src, threshold, name):
    (w, h) = src.size()
    dest = Image((w, h))
    for y in range(h):
        for x in range(w):
            c = src.getGray(x, y) > threshold
            dest.setGray(x, y, c)
    dest.writePng(name)

test1(lenna256bw, 0.5, "out001.png")
test1(lenna256bw, 0.4, "out002.png")
test1(lenna256bw, 0.6, "out003.png")
test1(gradient256bw, 0.5, "grad001.png")
test1(gradient256bw, 0.4, "grad002.png")
test1(gradient256bw, 0.6, "grad003.png")

# Output 4: 3-colour threshold
# Output 5: 5-colour threshold
def test2(src, colors, name):
    (w, h) = src.size()
    dest = Image((w, h))
    p = -0.0001 + colors
    q = colors - 1
    for y in range(h):
        for x in range(w):
            c = src.getGray(x, y)
            c = math.floor(c * p) / q
            dest.setGray(x, y, c)
    dest.writePng(name)

test2(lenna256bw, 3, "out004.png")
test2(lenna256bw, 5, "out005.png")
test2(gradient256bw, 3, "grad004.png")
test2(gradient256bw, 5, "grad005.png")

# Pattern 1: a 50% halftone pattern with various block sizes
dest = Image((320, 80))
for x in range(320):
    d = 8 >> (x / 80)
    for y in range(80):
        c = (x / d + y / d) & 1
        dest.setGray(x, y, c)
dest.writePng("pat001.png")

# Pattern 2: 25% and 75% halftone patterns with various block sizes
dest = Image((320, 80))
for x in range(320):
    d = 8 >> (x / 80)
    for y in range(40):
        c = ((x / d + y / d) & 1) or (y / d & 1)
        dest.setGray(x, y, c)
    for y in range(40, 80):
        c = ((x / d + y / d) & 1) and (y / d & 1)
        dest.setGray(x, y, c)
dest.writePng("pat002.png")

# Output 6: 20/40/60/80% threshold with 25/50/75% halftone patterns inbetween:
def test3(src, name):
    (w, h) = src.size()
    dest = Image((w, h))
    for y in range(h):
        for x in range(w):
            c = src.getGray(x, y)
            if c < 0.2:
                c = 0.
            elif c < 0.4:
                c = ((x + y) & 1) and (y & 1)
            elif c < 0.6:
                c = (x + y) & 1
            elif c < 0.8:
                c = ((x + y) & 1) or (y & 1)
            else:
                c = 1.
            dest.setGray(x, y, c)
    dest.writePng(name)

test3(lenna256bw, "out006.png")
test3(gradient256bw, "grad006.png")

# Pattern 3: vertical, mixed and horizontal black-white halftones
dest = Image((240, 80))
for y in range(80):
    for x in range(80):
        c = x & 1
        dest.setGray(x, y, c)
    for x in range(80, 160):
        c = (x / d + y / d) & 1
        dest.setGray(x, y, c)
    for x in range(160, 240):
        c = y & 1
        dest.setGray(x, y, c)
dest.writePng("pat003.png")

# Pattern 4: gamma-corrected 50% gray, black-white halftone, 50% gray
dest = Image((240, 80))
for y in range(80):
    for x in range(80):
        dest.setGray(x, y, Gamma.ItoC(0.5))
    for x in range(80, 160):
        c = (x + y) & 1
        dest.setGray(x, y, c)
    for x in range(160, 240):
        dest.setGray(x, y, 0.5)
dest.writePng("pat004.png")

# Pattern 5: gamma-corrected 50% gray, black-white halftone, 50% gray
dest = Image((400, 240))
for y in range(80):
    for x in range(400):
        if x < 80:
            c = 0.
        elif x < 160:
            c = ((x + y) & 1) and (y & 1)
        elif x < 240:
            c = (x + y) & 1
        elif x < 320:
            c = ((x + y) & 1) or (y & 1)
        else:
            c = 1.
        dest.setGray(x, y, c)
for y in range(80, 160):
    for x in range(400):
        dest.setGray(x, y, x / 80 / 4.)
for y in range(160, 240):
    for x in range(400):
        if x < 80:
            c = 0.
        elif x < 160:
            c = (((x + y) & 3) == 1) and ((y & 3) == 1)
        elif x < 240:
            c = ((x + y) & 1) and (y & 1)
        elif x < 320:
            c = (x + y) & 1
        else:
            c = 1.
        dest.setGray(x, y, c)
dest.writePng("pat005.png")

# Output 6: gamma-aware 20/40/60/80% threshold:
def test4(src, name):
    (w, h) = src.size()
    dest = Image((w, h))
    for y in range(h):
        for x in range(w):
            c = src.getGray(x, y)
            if c < 0.2:
                c = 0.
            elif c < 0.4:
                c = (((x + y) & 3) == 1) and ((y & 3) == 1)
            elif c < 0.6:
                c = ((x + y) & 1) and (y & 1)
            elif c < 0.8:
                c = (x + y) & 1
            else:
                c = 1.
            dest.setGray(x, y, c)
    dest.writePng(name)

test4(lenna256bw, "out007.png")
test4(gradient256bw, "grad007.png")


##############################################################################
# Only temporary cruft below this

src = lenna256bw
src = gradient256bw
(w, h) = src.size()

mat = [[  0,  8,  3, 11],
       [ 15,  4, 12,  7],
       [  2, 10,  1,  9],
       [ 13,  6, 14,  5]]
mat = [[  6,  7,  8,  9],
       [  5,  0,  1, 10],
       [  4,  3,  2, 11],
       [ 15, 14, 13, 12]]
mat = [[ 12,  5,  9, 13],
       [  8,  0,  1,  6],
       [  4,  3,  2, 10],
       [ 15, 11,  7, 14]]
mat = [[ 35, 24, 13, 14, 25, 32],
       [ 31, 12,  5,  6, 15, 26],
       [ 23,  4,  0,  1,  7, 16],
       [ 22, 11,  3,  2,  8, 17],
       [ 30, 21, 10,  9, 18, 27],
       [ 34, 29, 20, 19, 28, 33]]
mat = [[  0, 20, 30,  3, 23, 29],
       [ 12, 32, 18, 15, 35, 17],
       [ 27,  8,  4, 24, 11,  7],
       [  2, 22, 28,  1, 21, 31],
       [ 14, 34, 16, 13, 33, 19],
       [ 25, 10,  6, 26,  9,  5]]
dest = Image((w, h))
for y in range(h):
    for x in range(w):
        c = src.getGray(x, y)
        i = Gamma.CtoI(c)
        threshold = mat[x % 6][y % 6]
        c = math.floor(i * 35.999) > threshold
        dest.setGray(x, y, c)
dest.writePng("out008.png")

import sys
sys.exit(0)

# Create a dot-matrix pattern
mat = [[0, 2, 2, 3, 1],
       [2, 2, 0, 2, 3],
       [2, 0, 1, 1, 3],
       [3, 2, 1, 0, 3],
       [1, 3, 3, 3, 3]]
dest = Image((320, 64))
for x in range(320):
    d = x / 64
    for y in range(64):
        c = mat[y % 5][x % 5] >= d
        dest.setGray(x, y, c)
dest.writePng("pat003.png")