Павел Тысляцкий

for index, literal in enumerate(a):
     pass

#!/usr/bin/env python

rule_add = {
    'I': 1,
    'V': 5,
    'X': 10,
    'L': 50,
    'C': 100,
    'D': 500,
    'M': 1000,
}

rule_div = {
    ('I', 'V'): 3,
    ('I', 'X'): 8,
    ('X', 'L'): 30,
    ('X', 'C'): 80,
    ('C', 'D'): 300,
    ('C', 'M'): 800,
}

def roman_to_arabic(roman_number):
    number = 0
    prev_literal = None
    for literal in roman_number:
        if prev_literal and rule_add[prev_literal] < rule_add[literal]:
            number += rule_div[(prev_literal, literal)]
        else:
            number += rule_add[literal]
        prev_literal = literal
    return number



import unittest

class RomanNumTest(unittest.TestCase):
    def test_roman_num(self):
        self.assertEquals(roman_to_arabic('I'), 1)
        self.assertEquals(roman_to_arabic('II'), 2)
        self.assertEquals(roman_to_arabic('III'), 3)
        self.assertEquals(roman_to_arabic('IV'), 4)
        self.assertEquals(roman_to_arabic('V'), 5)
        self.assertEquals(roman_to_arabic('VI'), 6)
        self.assertEquals(roman_to_arabic('VII'), 7)
        self.assertEquals(roman_to_arabic('VIII'), 8)
        self.assertEquals(roman_to_arabic('IX'), 9)
        self.assertEquals(roman_to_arabic('X'), 10)
        self.assertEquals(roman_to_arabic('XXXI'), 31)
        self.assertEquals(roman_to_arabic('XLVI'), 46)
        self.assertEquals(roman_to_arabic('XCIX'), 99)
        self.assertEquals(roman_to_arabic('DLXXXIII'), 583)
        self.assertEquals(roman_to_arabic('DCCCLXXXVIII'), 888)
        self.assertEquals(roman_to_arabic('MDCLXVIII'), 1668)
        self.assertEquals(roman_to_arabic('MCMLXXXIX'), 1989)
        self.assertEquals(roman_to_arabic('MMX'), 2010)
        self.assertEquals(roman_to_arabic('MMXI'), 2011)
        self.assertEquals(roman_to_arabic('MMXII'), 2012)
        self.assertEquals(roman_to_arabic('MMMCMXCIX'), 3999)

    def __getitem__(self, index ):
        return self._children[index]

# -*- coding: utf-8 -*-

from math import log10, fabs
import Image


def check_pixel_colour(pixel, colour, delta=(0,0,0)):
    '''сравниваем цвет пиксиля с эталонным цветом с погрешностью дельта'''
    return (colour[0] - delta[0]) <= pixel[0] <= (colour[0] + delta[0]) and\
           (colour[1] - delta[1]) <= pixel[1] <= (colour[1] + delta[1]) and\
           (colour[2] - delta[2]) <= pixel[2] <= (colour[2] + delta[2])


def better_colour_value(pixels, colour):
    '''из списка цветов выбираем более подходящий эталонному цвету'''
    delta = 1024
    better_pixel = None
    for pixel in pixels:
        current_delta = fabs(pixel[0] - colour[0]) +\
                        fabs(pixel[1] - colour[1]) +\
                        fabs(pixel[2] - colour[2])
        if current_delta < delta:
            delta = current_delta
            better_pixel = pixel
    return better_pixel


def get_border_grids(image, grid_colour):
    '''
    получаем номера пиксилей по оси x первой и последней линий сетки, по оси y верхней и нижней
    данные пиксили соответствуют переданным граничным значениям сетки
    '''
    width, height = image.size
    for x in xrange(width):
        if check_pixel_colour(image.getpixel((x, 0)), grid_colour):
            yield x
            break
    for x in xrange(width - 1, -1, -1):
        if check_pixel_colour(image.getpixel((x, 0)), grid_colour):
            yield x
            break
    for y in xrange(height - 1, -1, -1):
        if check_pixel_colour(image.getpixel((0, y)), grid_colour):
            yield y
            break
    for y in xrange(height):
        if check_pixel_colour(image.getpixel((0, y)), grid_colour):
            yield y
            break


def get_linear_value(x, x1, x2, x1_value, x2_value):
    '''получаем значение для текущего пикселя с учетом граничных значений сетки для линейной оси'''
    k = (x2 - x1) / (x2_value - x1_value)
    b = x1 - k * x1_value
    return (x - b) / k


def get_log_value(x, x1, x2, x1_value, x2_value):
    '''получаем значение для текущего пикселя с учетом граничных значений сетки для логорифмической оси'''
    k = (x1 - x2) / (log10(x1_value) - log10(x2_value))
    b = x1 - k * log10(x1_value)
    return 10**((x - b) / k)


def process_graph(image_path, x1_value, x2_value, y1_value, y2_value, colour, delta, grid_colour):
    '''получаем список координат графика на изображении'''
    image = Image.open(image_path)
    width, height = image.size
    x1, x2, y1, y2 = get_border_grids(image, grid_colour)
    coordinates = []

    for x in xrange(width):
        pixels = {}
        for y in xrange(height):
            pixel = image.getpixel((x, y))
            if check_pixel_colour(pixel, colour, delta):
                pixels[pixel] = y
        if len(pixels) > 0:
            y = pixels[better_colour_value(pixels.keys(), colour)]
            x_value = get_log_value(x, x1, x2, x1_value, x2_value)
            y_value = get_linear_value(height - y, height - y1, height - y2, y1_value, y2_value)
            coordinates.append((x_value, y_value))

    return coordinates


if __name__ == '__main__':
    print process_graph('test_001.png', 10., 10000., -25., 10., (0,0,255), (10,10,50), (221,221,221))
    print process_graph('test_002.png', 30., 10000., 90., 132., (150,255,0), (50,50,10), (104,104,104))