From 298288847b400abeb89b472b0099f1c51a8ce8bd Mon Sep 17 00:00:00 2001 From: Darafei Praliaskouski Date: Wed, 20 Feb 2013 15:40:56 +0300 Subject: [PATCH] drules to mapcss converter --- tools/python/stylesheet/drules_struct_pb2.py | 806 ++++++++++++++++ tools/python/stylesheet/drules_to_mapcss.py | 449 +++++++++ tools/python/stylesheet/webcolors/LICENSE.txt | 28 + tools/python/stylesheet/webcolors/PKG-INFO | 439 +++++++++ tools/python/stylesheet/webcolors/README.txt | 421 +++++++++ tools/python/stylesheet/webcolors/__init__.py | 1 + tools/python/stylesheet/webcolors/setup.py | 21 + .../python/stylesheet/webcolors/webcolors.py | 881 ++++++++++++++++++ 8 files changed, 3046 insertions(+) create mode 100644 tools/python/stylesheet/drules_struct_pb2.py create mode 100644 tools/python/stylesheet/drules_to_mapcss.py create mode 100644 tools/python/stylesheet/webcolors/LICENSE.txt create mode 100644 tools/python/stylesheet/webcolors/PKG-INFO create mode 100644 tools/python/stylesheet/webcolors/README.txt create mode 100644 tools/python/stylesheet/webcolors/__init__.py create mode 100644 tools/python/stylesheet/webcolors/setup.py create mode 100644 tools/python/stylesheet/webcolors/webcolors.py diff --git a/tools/python/stylesheet/drules_struct_pb2.py b/tools/python/stylesheet/drules_struct_pb2.py new file mode 100644 index 0000000000..8276fc6cf4 --- /dev/null +++ b/tools/python/stylesheet/drules_struct_pb2.py @@ -0,0 +1,806 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! + +from google.protobuf import descriptor +from google.protobuf import message +from google.protobuf import reflection +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + + + +DESCRIPTOR = descriptor.FileDescriptor( + name='drules_struct.proto', + package='', + serialized_pb='\n\x13\x64rules_struct.proto\"*\n\x0c\x44\x61shDotProto\x12\n\n\x02\x64\x64\x18\x01 \x03(\x01\x12\x0e\n\x06offset\x18\x02 \x01(\x01\":\n\x0cPathSymProto\x12\x0c\n\x04name\x18\x01 \x02(\t\x12\x0c\n\x04step\x18\x02 \x02(\x01\x12\x0e\n\x06offset\x18\x03 \x01(\x01\"\xaf\x01\n\rLineRuleProto\x12\r\n\x05width\x18\x01 \x02(\x01\x12\r\n\x05\x63olor\x18\x02 \x02(\r\x12\x1e\n\x07\x64\x61shdot\x18\x03 \x01(\x0b\x32\r.DashDotProto\x12\x10\n\x08priority\x18\x04 \x02(\x05\x12\x1e\n\x07pathsym\x18\x05 \x01(\x0b\x32\r.PathSymProto\x12\x17\n\x04join\x18\x06 \x01(\x0e\x32\t.LineJoin\x12\x15\n\x03\x63\x61p\x18\x07 \x01(\x0e\x32\x08.LineCap\"\x9c\x01\n\x0cLineDefProto\x12\r\n\x05width\x18\x01 \x02(\x01\x12\r\n\x05\x63olor\x18\x02 \x02(\r\x12\x1e\n\x07\x64\x61shdot\x18\x03 \x01(\x0b\x32\r.DashDotProto\x12\x1e\n\x07pathsym\x18\x04 \x01(\x0b\x32\r.PathSymProto\x12\x17\n\x04join\x18\x06 \x01(\x0e\x32\t.LineJoin\x12\x15\n\x03\x63\x61p\x18\x07 \x01(\x0e\x32\x08.LineCap\"O\n\rAreaRuleProto\x12\r\n\x05\x63olor\x18\x01 \x02(\r\x12\x1d\n\x06\x62order\x18\x02 \x01(\x0b\x32\r.LineDefProto\x12\x10\n\x08priority\x18\x03 \x02(\x05\"I\n\x0fSymbolRuleProto\x12\x0c\n\x04name\x18\x01 \x02(\t\x12\x16\n\x0e\x61pply_for_type\x18\x02 \x01(\x05\x12\x10\n\x08priority\x18\x03 \x02(\x05\"j\n\x0f\x43\x61ptionDefProto\x12\x0e\n\x06height\x18\x01 \x02(\x05\x12\r\n\x05\x63olor\x18\x02 \x02(\r\x12\x14\n\x0cstroke_color\x18\x03 \x01(\r\x12\x10\n\x08offset_x\x18\x04 \x01(\x05\x12\x10\n\x08offset_y\x18\x05 \x01(\x05\"l\n\x10\x43\x61ptionRuleProto\x12!\n\x07primary\x18\x01 \x02(\x0b\x32\x10.CaptionDefProto\x12#\n\tsecondary\x18\x02 \x01(\x0b\x32\x10.CaptionDefProto\x12\x10\n\x08priority\x18\x03 \x02(\x05\"a\n\x0f\x43ircleRuleProto\x12\x0e\n\x06radius\x18\x01 \x02(\x01\x12\r\n\x05\x63olor\x18\x02 \x02(\r\x12\x1d\n\x06\x62order\x18\x03 \x01(\x0b\x32\r.LineDefProto\x12\x10\n\x08priority\x18\x04 \x02(\x05\"m\n\x11PathTextRuleProto\x12!\n\x07primary\x18\x01 \x02(\x0b\x32\x10.CaptionDefProto\x12#\n\tsecondary\x18\x02 \x01(\x0b\x32\x10.CaptionDefProto\x12\x10\n\x08priority\x18\x03 \x02(\x05\"\xed\x01\n\x10\x44rawElementProto\x12\r\n\x05scale\x18\x01 \x02(\x05\x12\x1d\n\x05lines\x18\x02 \x03(\x0b\x32\x0e.LineRuleProto\x12\x1c\n\x04\x61rea\x18\x03 \x01(\x0b\x32\x0e.AreaRuleProto\x12 \n\x06symbol\x18\x04 \x01(\x0b\x32\x10.SymbolRuleProto\x12\"\n\x07\x63\x61ption\x18\x05 \x01(\x0b\x32\x11.CaptionRuleProto\x12 \n\x06\x63ircle\x18\x06 \x01(\x0b\x32\x10.CircleRuleProto\x12%\n\tpath_text\x18\x07 \x01(\x0b\x32\x12.PathTextRuleProto\"G\n\x13\x43lassifElementProto\x12\x0c\n\x04name\x18\x01 \x02(\t\x12\"\n\x07\x65lement\x18\x02 \x03(\x0b\x32\x11.DrawElementProto\"4\n\x0e\x43ontainerProto\x12\"\n\x04\x63ont\x18\x01 \x03(\x0b\x32\x14.ClassifElementProto*4\n\x08LineJoin\x12\r\n\tROUNDJOIN\x10\x00\x12\r\n\tBEVELJOIN\x10\x01\x12\n\n\x06NOJOIN\x10\x02*3\n\x07LineCap\x12\x0c\n\x08ROUNDCAP\x10\x00\x12\x0b\n\x07\x42UTTCAP\x10\x01\x12\r\n\tSQUARECAP\x10\x02\x42\x02H\x03') + +_LINEJOIN = descriptor.EnumDescriptor( + name='LineJoin', + full_name='LineJoin', + filename=None, + file=DESCRIPTOR, + values=[ + descriptor.EnumValueDescriptor( + name='ROUNDJOIN', index=0, number=0, + options=None, + type=None), + descriptor.EnumValueDescriptor( + name='BEVELJOIN', index=1, number=1, + options=None, + type=None), + descriptor.EnumValueDescriptor( + name='NOJOIN', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=1415, + serialized_end=1467, +) + + +_LINECAP = descriptor.EnumDescriptor( + name='LineCap', + full_name='LineCap', + filename=None, + file=DESCRIPTOR, + values=[ + descriptor.EnumValueDescriptor( + name='ROUNDCAP', index=0, number=0, + options=None, + type=None), + descriptor.EnumValueDescriptor( + name='BUTTCAP', index=1, number=1, + options=None, + type=None), + descriptor.EnumValueDescriptor( + name='SQUARECAP', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=1469, + serialized_end=1520, +) + + +ROUNDJOIN = 0 +BEVELJOIN = 1 +NOJOIN = 2 +ROUNDCAP = 0 +BUTTCAP = 1 +SQUARECAP = 2 + + + +_DASHDOTPROTO = descriptor.Descriptor( + name='DashDotProto', + full_name='DashDotProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='dd', full_name='DashDotProto.dd', index=0, + number=1, type=1, cpp_type=5, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='offset', full_name='DashDotProto.offset', index=1, + number=2, type=1, cpp_type=5, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=23, + serialized_end=65, +) + + +_PATHSYMPROTO = descriptor.Descriptor( + name='PathSymProto', + full_name='PathSymProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='name', full_name='PathSymProto.name', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='step', full_name='PathSymProto.step', index=1, + number=2, type=1, cpp_type=5, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='offset', full_name='PathSymProto.offset', index=2, + number=3, type=1, cpp_type=5, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=67, + serialized_end=125, +) + + +_LINERULEPROTO = descriptor.Descriptor( + name='LineRuleProto', + full_name='LineRuleProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='width', full_name='LineRuleProto.width', index=0, + number=1, type=1, cpp_type=5, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='color', full_name='LineRuleProto.color', index=1, + number=2, type=13, cpp_type=3, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='dashdot', full_name='LineRuleProto.dashdot', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='priority', full_name='LineRuleProto.priority', index=3, + number=4, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='pathsym', full_name='LineRuleProto.pathsym', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='join', full_name='LineRuleProto.join', index=5, + number=6, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='cap', full_name='LineRuleProto.cap', index=6, + number=7, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=128, + serialized_end=303, +) + + +_LINEDEFPROTO = descriptor.Descriptor( + name='LineDefProto', + full_name='LineDefProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='width', full_name='LineDefProto.width', index=0, + number=1, type=1, cpp_type=5, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='color', full_name='LineDefProto.color', index=1, + number=2, type=13, cpp_type=3, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='dashdot', full_name='LineDefProto.dashdot', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='pathsym', full_name='LineDefProto.pathsym', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='join', full_name='LineDefProto.join', index=4, + number=6, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='cap', full_name='LineDefProto.cap', index=5, + number=7, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=306, + serialized_end=462, +) + + +_AREARULEPROTO = descriptor.Descriptor( + name='AreaRuleProto', + full_name='AreaRuleProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='color', full_name='AreaRuleProto.color', index=0, + number=1, type=13, cpp_type=3, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='border', full_name='AreaRuleProto.border', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='priority', full_name='AreaRuleProto.priority', index=2, + number=3, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=464, + serialized_end=543, +) + + +_SYMBOLRULEPROTO = descriptor.Descriptor( + name='SymbolRuleProto', + full_name='SymbolRuleProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='name', full_name='SymbolRuleProto.name', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='apply_for_type', full_name='SymbolRuleProto.apply_for_type', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='priority', full_name='SymbolRuleProto.priority', index=2, + number=3, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=545, + serialized_end=618, +) + + +_CAPTIONDEFPROTO = descriptor.Descriptor( + name='CaptionDefProto', + full_name='CaptionDefProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='height', full_name='CaptionDefProto.height', index=0, + number=1, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='color', full_name='CaptionDefProto.color', index=1, + number=2, type=13, cpp_type=3, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='stroke_color', full_name='CaptionDefProto.stroke_color', index=2, + number=3, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='offset_x', full_name='CaptionDefProto.offset_x', index=3, + number=4, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='offset_y', full_name='CaptionDefProto.offset_y', index=4, + number=5, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=620, + serialized_end=726, +) + + +_CAPTIONRULEPROTO = descriptor.Descriptor( + name='CaptionRuleProto', + full_name='CaptionRuleProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='primary', full_name='CaptionRuleProto.primary', index=0, + number=1, type=11, cpp_type=10, label=2, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='secondary', full_name='CaptionRuleProto.secondary', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='priority', full_name='CaptionRuleProto.priority', index=2, + number=3, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=728, + serialized_end=836, +) + + +_CIRCLERULEPROTO = descriptor.Descriptor( + name='CircleRuleProto', + full_name='CircleRuleProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='radius', full_name='CircleRuleProto.radius', index=0, + number=1, type=1, cpp_type=5, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='color', full_name='CircleRuleProto.color', index=1, + number=2, type=13, cpp_type=3, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='border', full_name='CircleRuleProto.border', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='priority', full_name='CircleRuleProto.priority', index=3, + number=4, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=838, + serialized_end=935, +) + + +_PATHTEXTRULEPROTO = descriptor.Descriptor( + name='PathTextRuleProto', + full_name='PathTextRuleProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='primary', full_name='PathTextRuleProto.primary', index=0, + number=1, type=11, cpp_type=10, label=2, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='secondary', full_name='PathTextRuleProto.secondary', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='priority', full_name='PathTextRuleProto.priority', index=2, + number=3, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=937, + serialized_end=1046, +) + + +_DRAWELEMENTPROTO = descriptor.Descriptor( + name='DrawElementProto', + full_name='DrawElementProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='scale', full_name='DrawElementProto.scale', index=0, + number=1, type=5, cpp_type=1, label=2, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='lines', full_name='DrawElementProto.lines', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='area', full_name='DrawElementProto.area', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='symbol', full_name='DrawElementProto.symbol', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='caption', full_name='DrawElementProto.caption', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='circle', full_name='DrawElementProto.circle', index=5, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='path_text', full_name='DrawElementProto.path_text', index=6, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=1049, + serialized_end=1286, +) + + +_CLASSIFELEMENTPROTO = descriptor.Descriptor( + name='ClassifElementProto', + full_name='ClassifElementProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='name', full_name='ClassifElementProto.name', index=0, + number=1, type=9, cpp_type=9, label=2, + has_default_value=False, default_value=unicode("", "utf-8"), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + descriptor.FieldDescriptor( + name='element', full_name='ClassifElementProto.element', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=1288, + serialized_end=1359, +) + + +_CONTAINERPROTO = descriptor.Descriptor( + name='ContainerProto', + full_name='ContainerProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + descriptor.FieldDescriptor( + name='cont', full_name='ContainerProto.cont', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + extension_ranges=[], + serialized_start=1361, + serialized_end=1413, +) + +_LINERULEPROTO.fields_by_name['dashdot'].message_type = _DASHDOTPROTO +_LINERULEPROTO.fields_by_name['pathsym'].message_type = _PATHSYMPROTO +_LINERULEPROTO.fields_by_name['join'].enum_type = _LINEJOIN +_LINERULEPROTO.fields_by_name['cap'].enum_type = _LINECAP +_LINEDEFPROTO.fields_by_name['dashdot'].message_type = _DASHDOTPROTO +_LINEDEFPROTO.fields_by_name['pathsym'].message_type = _PATHSYMPROTO +_LINEDEFPROTO.fields_by_name['join'].enum_type = _LINEJOIN +_LINEDEFPROTO.fields_by_name['cap'].enum_type = _LINECAP +_AREARULEPROTO.fields_by_name['border'].message_type = _LINEDEFPROTO +_CAPTIONRULEPROTO.fields_by_name['primary'].message_type = _CAPTIONDEFPROTO +_CAPTIONRULEPROTO.fields_by_name['secondary'].message_type = _CAPTIONDEFPROTO +_CIRCLERULEPROTO.fields_by_name['border'].message_type = _LINEDEFPROTO +_PATHTEXTRULEPROTO.fields_by_name['primary'].message_type = _CAPTIONDEFPROTO +_PATHTEXTRULEPROTO.fields_by_name['secondary'].message_type = _CAPTIONDEFPROTO +_DRAWELEMENTPROTO.fields_by_name['lines'].message_type = _LINERULEPROTO +_DRAWELEMENTPROTO.fields_by_name['area'].message_type = _AREARULEPROTO +_DRAWELEMENTPROTO.fields_by_name['symbol'].message_type = _SYMBOLRULEPROTO +_DRAWELEMENTPROTO.fields_by_name['caption'].message_type = _CAPTIONRULEPROTO +_DRAWELEMENTPROTO.fields_by_name['circle'].message_type = _CIRCLERULEPROTO +_DRAWELEMENTPROTO.fields_by_name['path_text'].message_type = _PATHTEXTRULEPROTO +_CLASSIFELEMENTPROTO.fields_by_name['element'].message_type = _DRAWELEMENTPROTO +_CONTAINERPROTO.fields_by_name['cont'].message_type = _CLASSIFELEMENTPROTO +DESCRIPTOR.message_types_by_name['DashDotProto'] = _DASHDOTPROTO +DESCRIPTOR.message_types_by_name['PathSymProto'] = _PATHSYMPROTO +DESCRIPTOR.message_types_by_name['LineRuleProto'] = _LINERULEPROTO +DESCRIPTOR.message_types_by_name['LineDefProto'] = _LINEDEFPROTO +DESCRIPTOR.message_types_by_name['AreaRuleProto'] = _AREARULEPROTO +DESCRIPTOR.message_types_by_name['SymbolRuleProto'] = _SYMBOLRULEPROTO +DESCRIPTOR.message_types_by_name['CaptionDefProto'] = _CAPTIONDEFPROTO +DESCRIPTOR.message_types_by_name['CaptionRuleProto'] = _CAPTIONRULEPROTO +DESCRIPTOR.message_types_by_name['CircleRuleProto'] = _CIRCLERULEPROTO +DESCRIPTOR.message_types_by_name['PathTextRuleProto'] = _PATHTEXTRULEPROTO +DESCRIPTOR.message_types_by_name['DrawElementProto'] = _DRAWELEMENTPROTO +DESCRIPTOR.message_types_by_name['ClassifElementProto'] = _CLASSIFELEMENTPROTO +DESCRIPTOR.message_types_by_name['ContainerProto'] = _CONTAINERPROTO + +class DashDotProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _DASHDOTPROTO + + # @@protoc_insertion_point(class_scope:DashDotProto) + +class PathSymProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _PATHSYMPROTO + + # @@protoc_insertion_point(class_scope:PathSymProto) + +class LineRuleProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _LINERULEPROTO + + # @@protoc_insertion_point(class_scope:LineRuleProto) + +class LineDefProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _LINEDEFPROTO + + # @@protoc_insertion_point(class_scope:LineDefProto) + +class AreaRuleProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _AREARULEPROTO + + # @@protoc_insertion_point(class_scope:AreaRuleProto) + +class SymbolRuleProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _SYMBOLRULEPROTO + + # @@protoc_insertion_point(class_scope:SymbolRuleProto) + +class CaptionDefProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CAPTIONDEFPROTO + + # @@protoc_insertion_point(class_scope:CaptionDefProto) + +class CaptionRuleProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CAPTIONRULEPROTO + + # @@protoc_insertion_point(class_scope:CaptionRuleProto) + +class CircleRuleProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CIRCLERULEPROTO + + # @@protoc_insertion_point(class_scope:CircleRuleProto) + +class PathTextRuleProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _PATHTEXTRULEPROTO + + # @@protoc_insertion_point(class_scope:PathTextRuleProto) + +class DrawElementProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _DRAWELEMENTPROTO + + # @@protoc_insertion_point(class_scope:DrawElementProto) + +class ClassifElementProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CLASSIFELEMENTPROTO + + # @@protoc_insertion_point(class_scope:ClassifElementProto) + +class ContainerProto(message.Message): + __metaclass__ = reflection.GeneratedProtocolMessageType + DESCRIPTOR = _CONTAINERPROTO + + # @@protoc_insertion_point(class_scope:ContainerProto) + +# @@protoc_insertion_point(module_scope) diff --git a/tools/python/stylesheet/drules_to_mapcss.py b/tools/python/stylesheet/drules_to_mapcss.py new file mode 100644 index 0000000000..eee2922eb7 --- /dev/null +++ b/tools/python/stylesheet/drules_to_mapcss.py @@ -0,0 +1,449 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import csv +import os + +import drules_struct_pb2 +from webcolors.webcolors import hex_to_color_name +from operator import * +from copy import * + +import sys +reload(sys) +sys.setdefaultencoding("utf-8") + +DATADIR = "../../../data" +files = { + "mapcss_mapping": os.path.join(DATADIR, 'mapcss-mapping.csv'), + "drules_proto": os.path.join(DATADIR, 'drules_proto.bin'), +} + +MINIMAL_WIDTH = .1 +LAST_ZOOM = 17 + +FLAVOUR = set(["JOSM"]) # "JOSM" +FLAVOUR = [] + + +def number(f): + if float(int(float(f))) == float(str(f)): + return int(float(f)) + return float(('%.2f' % float(f)).rstrip('0')) + + +def color_to_properties(color, prefix=""): + if prefix: + prefix += "-" + colorvar = prefix + "color" + opacityvar = prefix + "opacity" + dd = {} + dd[colorvar] = hex_to_color_name("#" + hex(int(color) % (0x1000000))[2:]) # leave only last 24 bits + opacity = (255 - (int(color) >> 24)) / 255. + if opacity != 1: + dd[opacityvar] = number(opacity) + return dd + +print """ +canvas { + background-color: #f1eee8; + default-lines: false; + default-points: false; +} + +way::* { + linejoin: round; + linecap: round; + fill-opacity: 0; + casing-linecap: none; + text-position: line; +} + +*::* { + text-halo-color: white; + text-anchor-horizontal: center; + text-anchor-vertical: center; +} + +node::* { + text-anchor-vertical: top; +} + +area::* { + text-position: center; + text-anchor-vertical: center; +} + +area[landuse], +area[natural], +area[leisure], +area[place] {fill-position: background} + +""" + +if True: + classificator = {} + classificator_mapping = {} + class_order = [] + for row in csv.reader(open(files['mapcss_mapping']), delimiter=';'): + try: + pairs = [i.strip(']').split("=") for i in row[1].split(',')[0].split('[')] + except: + print row + classificator_mapping[row[0].replace("|", "-")] = row[1] + kv = {} + for i in pairs: + if len(i) == 1: + if i[0]: + if i[0][0] == "!": + kv[i[0][1:].strip('?')] = "no" + else: + kv[i[0].strip('?')] = "yes" + else: + kv[i[0].strip('?')] = i[1] + classificator[row[0].replace("|", "-")] = kv + if row[2] != "x": + class_order.append(row[0].replace("|", "-")) + class_order.sort() + drules = drules_struct_pb2.ContainerProto() + drules.ParseFromString(open(files["drules_proto"]).read()) + names = set() + linejoins = {drules_struct_pb2.BEVELJOIN: "bevel", drules_struct_pb2.ROUNDJOIN: "round", drules_struct_pb2.NOJOIN: "none"} + linecaps = {drules_struct_pb2.SQUARECAP: "square", drules_struct_pb2.ROUNDCAP: "round", drules_struct_pb2.BUTTCAP: "none"} + deduped_sheet = {} + for elem in drules.cont: + visible_on_zooms = [] + if elem.name not in class_order and elem.element: + print >> sys.stderr, elem.name, "rendered but not in classificator" + continue + names.add(elem.name) + if not elem.element: + print >> sys.stderr, elem.name, "is not rendered" + continue + for el in elem.element: + etype = set() + zoom = el.scale + if zoom <= 0: + continue + # if zoom <= 1: + # zoom = -1 + visible_on_zooms.append(zoom) + selector = classificator_mapping[elem.name] + kvrules = [{}] + tdashes = False + for tline in el.lines: + if tline.pathsym.name or tline.dashdot.dd: + tdashes = True + if len(el.lines) == 2 and not tdashes: # and not "bridge" in elem.name: + """ + line and casing, no dashes + """ + etype.add("line") + if el.lines[0].priority < el.lines[1].priority: + tline = el.lines[1] + tcasing = el.lines[0] + elif el.lines[0].priority > el.lines[1].priority: + tline = el.lines[0] + tcasing = el.lines[1] + else: + print >> sys.stderr, elem.name, "has two lines on same z" + twidth = tline.width + if twidth < MINIMAL_WIDTH: + print >> sys.stderr, elem.name, "has invisible lines on zoom", zoom + else: + # tlinedashes = + kvrules[0]["width"] = number(twidth) + kvrules[0].update(color_to_properties(tline.color)) + kvrules[0]["z-index"] = number(tline.priority) + tlinedashes = ",".join([str(number(t)) for t in tline.dashdot.dd]) + if tlinedashes: + kvrules[0]["dashes"] = tlinedashes + if tline.HasField("cap"): + kvrules[0]["linecap"] = linecaps.get(tline.cap, 'round') + if tline.HasField("join"): + kvrules[0]["linejoin"] = linejoins.get(tline.join, 'round') + tcasingwidth = (tcasing.width - tline.width) / 2 + if ("width" not in kvrules[0]) and tcasingwidth < MINIMAL_WIDTH: + print >> sys.stderr, elem.name, "has invisible casing on zoom", zoom + else: + tcasingdashes = ",".join([str(number(t)) for t in tcasing.dashdot.dd]) + if tlinedashes != tcasingdashes: + kvrules[0]["casing-dashes"] = tcasingdashes + kvrules[0]["casing-width"] = number(tcasingwidth) + kvrules[0].update(color_to_properties(tcasing.color, "casing")) + if tcasing.HasField("cap"): + kvrules[0]["casing-linecap"] = linecaps.get(tcasing.cap, 'round') + if tcasing.HasField("join"): + kvrules[0]["casing-linejoin"] = linejoins.get(tcasing.join, 'round') + elif len(el.lines) > 0: + """ + do we have lines at all? + """ + etype.add("line") + for tline in el.lines: + tkv = {} + twidth = tline.width + tlinedashes = ",".join([str(number(t)) for t in tline.dashdot.dd]) + if twidth < MINIMAL_WIDTH: + if not tline.pathsym.name: + print >> sys.stderr, elem.name, "has invisible lines on zoom", zoom + else: + tkv["width"] = number(twidth) + tkv.update(color_to_properties(tline.color)) + tkv["z-index"] = number(tline.priority) + if tline.HasField("cap"): + tkv["linecap"] = linecaps.get(tline.cap, 'round') + if tline.HasField("join"): + tkv["linejoin"] = linejoins.get(tline.join, 'round') + if tline.dashdot.dd: + tkv["dashes"] = tlinedashes + for trule in kvrules: + if "width" not in trule and tkv["z-index"] == trule.get("z-index", tkv["z-index"]): + trule.update(tkv) + break + else: + kvrules.append(tkv) + if tline.pathsym.name: + kvrules[0]["pattern-image"] = tline.pathsym.name + ".svg" + kvrules[0]["pattern-spacing"] = number(tline.pathsym.step - 16) + kvrules[0]["pattern-offset"] = number(tline.pathsym.offset) + kvrules[0]["z-index"] = number(tline.priority) + + if el.area.color: + etype.add("area") + tkv = {} + tkv["z-index"] = el.area.priority + tkv.update(color_to_properties(el.area.color, "fill")) + + # if el.area.border.width: + # tline = el.area.border + # tkv["casing-width"] = str(tline.width) + # tkv.update(color_to_properties(tline.color, "casing")) + # if tline.dashdot.dd: + # tkv["casing-dashes"] = ",".join([str(t) for t in tline.dashdot.dd]) + if not kvrules[0]: + kvrules[0] = tkv + else: + kvrules.append(tkv) + + if el.symbol.name: + if el.symbol.apply_for_type == 0: + etype.add("node") + etype.add("area") + elif el.symbol.apply_for_type == 1: + etype.add("node") + elif el.symbol.apply_for_type == 2: + etype.add("area") + kvrules[0]["icon-image"] = el.symbol.name + ".svg" + + if el.circle.radius: + etype.add("node") + kvrules[0]["symbol-shape"] = "circle" + kvrules[0]["symbol-size"] = number(el.circle.radius) + kvrules[0].update(color_to_properties(el.circle.color, "symbol-fill")) + + if el.caption.primary.height: + etype.add("node") + etype.add("area") + kvrules[0].update(color_to_properties(el.caption.primary.color, "text")) + if el.caption.primary.stroke_color: + kvrules[0].update(color_to_properties(el.caption.primary.stroke_color, "text-halo")) + kvrules[0]["text-halo-radius"] = 2 + kvrules[0]["text"] = "name" + if "building" in selector: + kvrules[0]["text"] = "addr:housenumber" + kvrules[0]["font-size"] = el.caption.primary.height + if el.caption.primary.offset_y: + kvrules[0]["text-offset"] = el.caption.primary.offset_y + + if el.caption.secondary.height: + tkv = {} + etype.add("node") + etype.add("area") + tkv.update(color_to_properties(el.caption.secondary.color, "text")) + if el.caption.secondary.stroke_color: + tkv.update(color_to_properties(el.caption.secondary.stroke_color, "text-halo")) + tkv["text-halo-radius"] = 2 + tkv["text"] = "int_name" + tkv["font-size"] = el.caption.secondary.height + if el.caption.primary.offset_y: + tkv["text-offset"] = el.caption.secondary.offset_y + kvrules.append(tkv) + + if el.path_text.primary.height: + etype.add("line") + kvrules[0].update(color_to_properties(el.path_text.primary.color, "text")) + if el.path_text.primary.stroke_color: + kvrules[0].update(color_to_properties(el.path_text.primary.stroke_color, "text-halo")) + kvrules[0]["text-halo-radius"] = 2 + kvrules[0]["text"] = "name" + kvrules[0]["text-position"] = "line" + if "building" in selector: + kvrules[0]["text"] = "addr:housenumber" + kvrules[0]["font-size"] = el.path_text.primary.height + + if el.path_text.secondary.height: + tkv = {} + etype.add("line") + tkv.update(color_to_properties(el.path_text.secondary.color, "text")) + if el.path_text.secondary.stroke_color: + tkv.update(color_to_properties(el.path_text.secondary.stroke_color, "text-halo")) + tkv["text-halo-radius"] = 2 + tkv["text"] = "int_name" + tkv["text-position"] = "line" + tkv["font-size"] = el.path_text.secondary.height + kvrules.append(tkv) + + tt = [] + if "[area?]" in selector: + etype.discard("way") + etype.discard("line") + etype.add("area") + selector = selector.replace("[area?]", "") + if ("line" in etype) and ("JOSM" in FLAVOUR): + etype.add("way") + etype.discard("line") + for tetype in etype: + # lzoom = zoom + # if zoom == LAST_ZOOM: + # lzoom = str(zoom)+"-" + for tsel in selector.split(","): + tsel = tsel.strip() + # tt.append( "%(tetype)s|z%(lzoom)s%(tsel)s"%(locals())) + tt.append([tetype, zoom, zoom, tsel, '']) + tl = 0 + for kvrul in kvrules: + if not kvrul: + continue + tsubpart = "" + + filt = { + #'z': [['z-index', 'fill-position'], []], + #'halo': [['text-halo-radius', 'text-halo-color'], []], + 'text': [['font-size', 'text-offset', 'text', 'text-color', 'text-position', 'text-halo-radius', 'text-halo-color'], []], + #'casing': ['casing-width', 'casing-dashes', 'casing-color'], + 'icon': [['icon-image', 'symbol-shape', 'symbol-size', 'symbol-fill-color'], ['node', 'area']], + 'fill': [['fill-color', 'fill-opacity'], ['area']] + } + genkv = [] + for k, v in filt.iteritems(): + f = {} + for vi in v[0]: + if vi in kvrul: + f[vi] = kvrul[vi] + del kvrul[vi] + if f: + genkv.append(f) + genkv.append(kvrul) + for kvrule in genkv: + tl += 1 + # print selector + if (tl > 1) or ("bridge" in selector) or ("junction" in selector): + tsubpart = "::d%sp%s" % (elem.name.count("-"), tl) + if ("bridge" in selector): + kvrule['z-index'] = tl + if "dashes" in kvrule: + kvrule["linecap"] = "none" + if float(kvrule.get('z-index', 0)) < -5000: + kvrule['fill-position'] = 'background' + if "z-index" in kvrule: + del kvrule['z-index'] + # kvrule['z-index'] = float(kvrule.get('z-index',0)) + 9962 + if float(kvrule.get('z-index', 0)) > 10000: + kvrule['-x-kot-layer'] = 'top' + kvrule['z-index'] = float(kvrule.get('z-index', 0)) - 10000 + if float(kvrule.get('fill-opacity', 1)) == 0: + for discard in ['fill-color', 'fill-opacity', 'z-index', 'fill-position']: + if discard in kvrule: + del kvrule[discard] + if float(kvrule.get('opacity', 1)) == 0: + for discard in ['color', 'width', 'z-index']: + if discard in kvrule: + del kvrule[discard] + if float(kvrule.get('z-index', 0)) == 0: + if 'z-index' in kvrule: + del kvrule['z-index'] + key = kvrule.copy() + # if "z-index" in key: + # del key["z-index"] + if not kvrule: + continue + key = (frozenset(key.items())) + minzoom = min([i[1] for i in tt]) + if key not in deduped_sheet: + deduped_sheet[key] = { + "sel": [], + "maxz": kvrule.get('z-index', 0), + "minz": kvrule.get('z-index', 0), + "minzoom": minzoom, + "z": kvrule.get('z-index', 0), + "kv": {} + } + tt = deepcopy(tt) + for t in tt: + t[-1] = tsubpart + deduped_sheet[key]['sel'].extend(tt) + deduped_sheet[key]['maxz'] = max(deduped_sheet[key]['maxz'], kvrule.get('z-index', 0)) + deduped_sheet[key]['minz'] = max(deduped_sheet[key]['minz'], kvrule.get('z-index', 0)) + deduped_sheet[key]['z'] = number((deduped_sheet[key]['minz'] + deduped_sheet[key]['maxz']) / 2) + deduped_sheet[key]['minzoom'] = min(deduped_sheet[key]['minzoom'], minzoom) + deduped_sheet[key]['kv'] = kvrule + # else: + # print >> sys.stderr, selector, el + skipped_unstyled_zooms = set(range(min(visible_on_zooms), max(visible_on_zooms) + 1)).difference(visible_on_zooms) + if skipped_unstyled_zooms: + print >> sys.stderr, elem.name, "has no styles available for zooms", ", ".join([str(i) for i in skipped_unstyled_zooms]) + # print len(deduped_sheet) + dds = deduped_sheet.keys() + dds.sort(lambda k, v: int(deduped_sheet[k]['minzoom'] - deduped_sheet[v]['minzoom'])) + + allz = list(set([f['z'] for f in deduped_sheet.values()])) + allz.sort() + for tk in dds: + tv = deduped_sheet[tk] + tv['sel'].sort(key=itemgetter(0, 4, 3, 1, 2)) + + def dedup_zooms(lst, item): + if lst: + lst[-1] = lst[-1][:] + if lst[-1][0] == item[0] and lst[-1][3] in item[3] and lst[-1][4] == item[4] and lst[-1][2] >= item[2] and lst[-1][1] <= item[1]: + return lst + if lst[-1][0] == item[0] and lst[-1][3] == item[3] and lst[-1][4] == item[4] and lst[-1][2] == (item[1] - 1): + lst[-1][2] = item[2] + return lst + lst.append(item) + return lst + tv['sel'] = reduce(dedup_zooms, tv['sel'], []) + + def format_string(i): + i = i[:] + dash = '-' + zmark = '|z' + if i[2] == LAST_ZOOM: + i[2] = '' + if i[1] == i[2]: + i[2] = '' + dash = '' + if i[1] <= 1: + i[1] = '' + if i[1] == i[2] and i[1] == '': + zmark = '' + dash = '' + return "%s%s%s%s%s%s%s" % (i[0], zmark, i[1], dash, i[2], i[3], i[4]) + + tv['sel'] = [format_string(i) for i in tv['sel']] + print (",\n").join([i for i in tv['sel']]) + print "{" + kvrule = tv['kv'] + kvrule['z-index'] = allz.index(tv['z']) + for k, v in kvrule.iteritems(): + v = str(v) + if k == "z-index" and str(number(v)) == "0": + continue + # elif k == "z-index": + # v = str(2000 - int(v)) + if " " in v or ":" in v or not v: + v = '"' + v + '"' + print " " + k + ":\t" + str(v) + ";" + print "}" + for i in names.symmetric_difference(class_order): + print >> sys.stderr, i, "in classificator but not rendered" diff --git a/tools/python/stylesheet/webcolors/LICENSE.txt b/tools/python/stylesheet/webcolors/LICENSE.txt new file mode 100644 index 0000000000..61deabe362 --- /dev/null +++ b/tools/python/stylesheet/webcolors/LICENSE.txt @@ -0,0 +1,28 @@ +Copyright (c) 2008-2009, James Bennett +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the author nor the names of other + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/tools/python/stylesheet/webcolors/PKG-INFO b/tools/python/stylesheet/webcolors/PKG-INFO new file mode 100644 index 0000000000..baab7fc15c --- /dev/null +++ b/tools/python/stylesheet/webcolors/PKG-INFO @@ -0,0 +1,439 @@ +Metadata-Version: 1.0 +Name: webcolors +Version: 1.3 +Summary: A library for working with sRGB color specifications as used in HTML and CSS. +Home-page: http://www.bitbucket.org/ubernostrum/webcolors/overview/ +Author: James Bennett +Author-email: james@b-list.org +License: UNKNOWN +Download-URL: http://bitbucket.org/ubernostrum/webcolors/downloads/webcolors-1.3.tar.gz +Description: Web colors + ========== + + A simple library for working with the color names and color codes + defined by the HTML and CSS specifications. + + + An overview of HTML and CSS colors + ---------------------------------- + + Colors on the Web are specified in `the sRGB color space`_, where each + color is made up of a red component, a green component and a blue + component. This is useful because it maps (fairly) cleanly to the red, + green and blue components of pixels on a computer display, and to the + cone cells of a human eye, which come in three sets roughly + corresponding to the wavelengths of light associated with red, green + and blue. + + `The HTML 4 standard`_ defines two ways to specify sRGB colors: + + * A hash mark ('#') followed by three pairs of hexdecimal digits, + specifying values for red, green and blue components in that order; + for example, ``#0099cc``. Since each pair of hexadecimal digits can + express 256 different values, this allows up to 256**3 or 16,777,216 + unique colors to be specified (though, due to differences in display + technology, not all of these colors may be clearly distinguished on + any given physical display). + + * A set of predefined color names which correspond to specific + hexadecimal values; for example, ``white``. HTML 4 defines sixteen + such colors. + + `The CSS 2 standard`_ allows any valid HTML 4 color specification, and + adds three new ways to specify sRGB colors: + + * A hash mark followed by three hexadecimal digits, which is expanded + into three hexadecimal pairs by repeating each digit; thus ``#09c`` + is equivalent to ``#0099cc``. + + * The string 'rgb', followed by parentheses, between which are three + numeric values each between 0 and 255, inclusive, which are taken to + be the values of the red, green and blue components in that order; + for example, ``rgb(0, 153, 204)``. + + * The same as above, except using percentages instead of numeric + values; for example, ``rgb(0%, 60%, 80%)``. + + `The CSS 2.1 revision`_ does not add any new methods of specifying + sRGB colors, but does add one additional named color. + + `The CSS 3 color module`_ (currently a W3C Candidate Recommendation) + adds one new way to specify sRGB colors: + + * A hue-saturation-lightness triple (HSL), using the construct + ``hsl()``. + + It also adds support for variable opacity of colors, by allowing the + specification of alpha-channel information, through the ``rgba()`` and + ``hsla()`` constructs, which are identical to ``rgb()`` and ``hsl()`` + with one exception: a fourth value is supplied, indicating the level + of opacity from ``0.0`` (completely transparent) to ``1.0`` + (completely opaque). Though not technically a color, the keyword + ``transparent`` is also made available in lieu of a color value, and + corresponds to ``rgba(0,0,0,0)``. + + Additionally, CSS3 defines a new set of color names; this set is taken + directly from the named colors defined for SVG (Scalable Vector + Graphics) markup, and is a proper superset of the named colors defined + in CSS 2.1. This set also has significant overlap with traditional X11 + color sets as defined by the ``rgb.txt`` file on many Unix and + Unix-like operating systems, though the correspondence is not exact; + the set of X11 colors is not standardized, and the set of CSS3 colors + contains some definitions which diverge significantly from customary + X11 definitions (for example, CSS3's ``green`` is not equivalent to + X11's ``green``; the value which X11 designates ``green`` is + designated ``lime`` in CSS3). + + .. _the sRGB color space: http://www.w3.org/Graphics/Color/sRGB + .. _The HTML 4 standard: http://www.w3.org/TR/html401/types.html#h-6.5 + .. _The CSS 2 standard: http://www.w3.org/TR/REC-CSS2/syndata.html#value-def-color + .. _The CSS 2.1 revision: http://www.w3.org/TR/CSS21/ + .. _The CSS 3 color module: http://www.w3.org/TR/css3-color/ + + What this module supports + ------------------------- + + The mappings and functions within this module support the following + methods of specifying sRGB colors, and conversions between them: + + * Six-digit hexadecimal. + + * Three-digit hexadecimal. + + * Integer ``rgb()`` triplet. + + * Percentage ``rgb()`` triplet. + + * Varying selections of predefined color names (see below). + + This module does not support ``hsl()`` triplets, nor does it support + opacity/alpha-channel information via ``rgba()`` or ``hsla()``. + + If you need to convert between RGB-specified colors and HSL-specified + colors, or colors specified via other means, consult `the colorsys + module`_ in the Python standard library, which can perform conversions + amongst several common color spaces. + + .. _the colorsys module: http://docs.python.org/library/colorsys.html + + Normalization + ------------- + + For colors specified via hexadecimal values, this module will accept + input in the following formats: + + * A hash mark (#) followed by three hexadecimal digits, where letters + may be upper- or lower-case. + + * A hash mark (#) followed by six hexadecimal digits, where letters + may be upper- or lower-case. + + For output which consists of a color specified via hexadecimal values, + and for functions which perform intermediate conversion to hexadecimal + before returning a result in another format, this module always + normalizes such values to the following format: + + * A hash mark (#) followed by six hexadecimal digits, with letters + forced to lower-case. + + The function ``normalize_hex()`` in this module can be used to perform + this normalization manually if desired; see its documentation for an + explanation of the normalization process. + + For colors specified via predefined names, this module will accept + input in the following formats: + + * An entirely lower-case name, such as ``aliceblue``. + + * A name using initial capitals, such as ``AliceBlue``. + + For output which consists of a color specified via a predefined name, + and for functions which perform intermediate conversion to a + predefined name before returning a result in another format, this + module always normalizes such values to be entirely lower-case. + + Mappings of color names + ----------------------- + + For each set of defined color names -- HTML 4, CSS 2, CSS 2.1 and CSS + 3 -- this module exports two mappings: one of normalized color names + to normalized hexadecimal values, and one of normalized hexadecimal + values to normalized color names. These eight mappings are as follows: + + ``html4_names_to_hex`` + Mapping of normalized HTML 4 color names to normalized hexadecimal + values. + + ``html4_hex_to_names`` + Mapping of normalized hexadecimal values to normalized HTML 4 + color names. + + ``css2_names_to_hex`` + Mapping of normalized CSS 2 color names to normalized hexadecimal + values. Because CSS 2 defines the same set of named colors as HTML + 4, this is merely an alias for ``html4_names_to_hex``. + + ``css2_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS 2 color + nams. For the reasons described above, this is merely an alias for + ``html4_hex_to_names``. + + ``css21_names_to_hex`` + Mapping of normalized CSS 2.1 color names to normalized + hexadecimal values. This is identical to ``html4_names_to_hex``, + except for one addition: ``orange``. + + ``css21_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS 2.1 + color names. As above, this is identical to ``html4_hex_to_names`` + except for the addition of ``orange``. + + ``css3_names_to_hex`` + Mapping of normalized CSS3 color names to normalized hexadecimal + values. + + ``css3_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS3 color + names. + + Normalization functions + ----------------------- + + ``normalize_hex(hex_value)`` + Normalize a hexadecimal color value to the following form and + return the result:: + + #[a-f0-9]{6} + + In other words, the following transformations are applied as + needed: + + * If the value contains only three hexadecimal digits, it is + expanded to six. + + * The value is normalized to lower-case. + + If the supplied value cannot be interpreted as a hexadecimal color + value, ``ValueError`` is raised. + + Example: + + >>> normalize_hex('#09c') + '#0099cc' + + Conversions from named colors + ----------------------------- + + ``name_to_hex(name, spec='css3')`` + Convert a color name to a normalized hexadecimal color value. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Example: + + >>> name_to_hex('deepskyblue') + '#00bfff' + + ``name_to_rgb(name, spec='css3')`` + Convert a color name to a 3-tuple of integers suitable for use in + an ``rgb()`` triplet specifying that color. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Example: + + >>> name_to_rgb('navy') + (0, 0, 128) + + ``name_to_rgb_percent(name, spec='css3')`` + Convert a color name to a 3-tuple of percentages suitable for use + in an ``rgb()`` triplet specifying that color. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Example: + + >>> name_to_rgb_percent('navy') + ('0%', '0%', '50%') + + + Conversions from hexadecimal values + ----------------------------------- + + ``hex_to_name(hex_value, spec='css3')`` + Convert a hexadecimal color value to its corresponding normalized + color name, if any such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The hexadecimal value will be normalized before being looked up, + and when no color name for the value is found in the given + specification, ``ValueError`` is raised. + + Example: + + >>> hex_to_name('#000080') + 'navy' + + ``hex_to_rgb(hex_value)`` + Convert a hexadecimal color value to a 3-tuple of integers + suitable for use in an ``rgb()`` triplet specifying that color. + + The hexadecimal value will be normalized before being converted. + + Example: + + >>> hex_to_rgb('#000080') + (0, 0, 128) + + ``hex_to_rgb_percent(hex_value)`` + Convert a hexadecimal color value to a 3-tuple of percentages + suitable for use in an ``rgb()`` triplet representing that color. + + The hexadecimal value will be normalized before converting. + + Example: + + >>> hex_to_rgb_percent('#ffffff') + ('100%', '100%', '100%') + + + Conversions from integer rgb() triplets + --------------------------------------- + + ``rgb_to_name(rgb_triplet, spec='css3')`` + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to its corresponding normalized color name, if any + such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + If there is no matching name, ``ValueError`` is raised. + + Example: + + >>> rgb_to_name((0, 0, 0)) + 'black' + + ``rgb_to_hex(rgb_triplet)`` + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to a normalized hexadecimal value for that color. + + Example: + + >>> rgb_to_hex((255, 255, 255)) + '#ffffff' + + ``rgb_to_rgb_percent(rgb_triplet)`` + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to a 3-tuple of percentages suitable for use in + representing that color. + + This function makes some trade-offs in terms of the accuracy of + the final representation; for some common integer values, + special-case logic is used to ensure a precise result (e.g., + integer 128 will always convert to '50%', integer 32 will always + convert to '12.5%'), but for all other values a standard Python + ``float`` is used and rounded to two decimal places, which may + result in a loss of precision for some values. + + Examples: + + >>> rgb_to_rgb_percent((255, 255, 255)) + ('100%', '100%', '100%') + >>> rgb_to_rgb_percent((0, 0, 128)) + ('0%', '0%', '50%') + >>> rgb_to_rgb_percent((33, 56, 192)) + ('12.94%', '21.96%', '75.29%') + >>> rgb_to_rgb_percent((64, 32, 16)) + ('25%', '12.5%', '6.25%') + + + Conversions from percentage rgb() triplets + ------------------------------------------ + + ``rgb_percent_to_name(rgb_percent_triplet, spec='css3')`` + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to its corresponding normalized color name, if any + such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + If there is no matching name, ``ValueError`` is raised. + + Example: + + >>> rgb_percent_to_name(('0%', '0%', '50%')) + 'navy' + + ``rgb_percent_to_hex(rgb_percent_triplet)`` + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to a normalized hexadecimal color value for that + color. + + Example: + + >>> rgb_percent_to_hex(('100%', '100%', '0%')) + '#ffff00' + + ``rgb_percent_to_rgb(rgb_percent_triplet)`` + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to a 3-tuple of integers suitable for use in + representing that color. + + Some precision may be lost in this conversion. See the note + regarding precision for ``rgb_to_rgb_percent()`` for details; + generally speaking, the following is true for any 3-tuple ``t`` of + integers in the range 0...255 inclusive:: + + t == rgb_percent_to_rgb(rgb_to_rgb_percent(t)) + + Examples: + + >>> rgb_percent_to_rgb(('100%', '100%', '100%')) + (255, 255, 255) + >>> rgb_percent_to_rgb(('0%', '0%', '50%')) + (0, 0, 128) + >>> rgb_percent_to_rgb(('25%', '12.5%', '6.25%')) + (64, 32, 16) + >>> rgb_percent_to_rgb(('12.94%', '21.96%', '75.29%')) + (33, 56, 192) + +Platform: UNKNOWN +Classifier: Development Status :: 5 - Production/Stable +Classifier: Environment :: Web Environment +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Topic :: Utilities diff --git a/tools/python/stylesheet/webcolors/README.txt b/tools/python/stylesheet/webcolors/README.txt new file mode 100644 index 0000000000..4d95ae8cd6 --- /dev/null +++ b/tools/python/stylesheet/webcolors/README.txt @@ -0,0 +1,421 @@ +Web colors +========== + +A simple library for working with the color names and color codes +defined by the HTML and CSS specifications. + + +An overview of HTML and CSS colors +---------------------------------- + +Colors on the Web are specified in `the sRGB color space`_, where each +color is made up of a red component, a green component and a blue +component. This is useful because it maps (fairly) cleanly to the red, +green and blue components of pixels on a computer display, and to the +cone cells of a human eye, which come in three sets roughly +corresponding to the wavelengths of light associated with red, green +and blue. + +`The HTML 4 standard`_ defines two ways to specify sRGB colors: + +* A hash mark ('#') followed by three pairs of hexdecimal digits, + specifying values for red, green and blue components in that order; + for example, ``#0099cc``. Since each pair of hexadecimal digits can + express 256 different values, this allows up to 256**3 or 16,777,216 + unique colors to be specified (though, due to differences in display + technology, not all of these colors may be clearly distinguished on + any given physical display). + +* A set of predefined color names which correspond to specific + hexadecimal values; for example, ``white``. HTML 4 defines sixteen + such colors. + +`The CSS 2 standard`_ allows any valid HTML 4 color specification, and +adds three new ways to specify sRGB colors: + +* A hash mark followed by three hexadecimal digits, which is expanded + into three hexadecimal pairs by repeating each digit; thus ``#09c`` + is equivalent to ``#0099cc``. + +* The string 'rgb', followed by parentheses, between which are three + numeric values each between 0 and 255, inclusive, which are taken to + be the values of the red, green and blue components in that order; + for example, ``rgb(0, 153, 204)``. + +* The same as above, except using percentages instead of numeric + values; for example, ``rgb(0%, 60%, 80%)``. + +`The CSS 2.1 revision`_ does not add any new methods of specifying +sRGB colors, but does add one additional named color. + +`The CSS 3 color module`_ (currently a W3C Candidate Recommendation) +adds one new way to specify sRGB colors: + +* A hue-saturation-lightness triple (HSL), using the construct + ``hsl()``. + +It also adds support for variable opacity of colors, by allowing the +specification of alpha-channel information, through the ``rgba()`` and +``hsla()`` constructs, which are identical to ``rgb()`` and ``hsl()`` +with one exception: a fourth value is supplied, indicating the level +of opacity from ``0.0`` (completely transparent) to ``1.0`` +(completely opaque). Though not technically a color, the keyword +``transparent`` is also made available in lieu of a color value, and +corresponds to ``rgba(0,0,0,0)``. + +Additionally, CSS3 defines a new set of color names; this set is taken +directly from the named colors defined for SVG (Scalable Vector +Graphics) markup, and is a proper superset of the named colors defined +in CSS 2.1. This set also has significant overlap with traditional X11 +color sets as defined by the ``rgb.txt`` file on many Unix and +Unix-like operating systems, though the correspondence is not exact; +the set of X11 colors is not standardized, and the set of CSS3 colors +contains some definitions which diverge significantly from customary +X11 definitions (for example, CSS3's ``green`` is not equivalent to +X11's ``green``; the value which X11 designates ``green`` is +designated ``lime`` in CSS3). + +.. _the sRGB color space: http://www.w3.org/Graphics/Color/sRGB +.. _The HTML 4 standard: http://www.w3.org/TR/html401/types.html#h-6.5 +.. _The CSS 2 standard: http://www.w3.org/TR/REC-CSS2/syndata.html#value-def-color +.. _The CSS 2.1 revision: http://www.w3.org/TR/CSS21/ +.. _The CSS 3 color module: http://www.w3.org/TR/css3-color/ + +What this module supports +------------------------- + +The mappings and functions within this module support the following +methods of specifying sRGB colors, and conversions between them: + +* Six-digit hexadecimal. + +* Three-digit hexadecimal. + +* Integer ``rgb()`` triplet. + +* Percentage ``rgb()`` triplet. + +* Varying selections of predefined color names (see below). + +This module does not support ``hsl()`` triplets, nor does it support +opacity/alpha-channel information via ``rgba()`` or ``hsla()``. + +If you need to convert between RGB-specified colors and HSL-specified +colors, or colors specified via other means, consult `the colorsys +module`_ in the Python standard library, which can perform conversions +amongst several common color spaces. + +.. _the colorsys module: http://docs.python.org/library/colorsys.html + +Normalization +------------- + +For colors specified via hexadecimal values, this module will accept +input in the following formats: + +* A hash mark (#) followed by three hexadecimal digits, where letters + may be upper- or lower-case. + +* A hash mark (#) followed by six hexadecimal digits, where letters + may be upper- or lower-case. + +For output which consists of a color specified via hexadecimal values, +and for functions which perform intermediate conversion to hexadecimal +before returning a result in another format, this module always +normalizes such values to the following format: + +* A hash mark (#) followed by six hexadecimal digits, with letters + forced to lower-case. + +The function ``normalize_hex()`` in this module can be used to perform +this normalization manually if desired; see its documentation for an +explanation of the normalization process. + +For colors specified via predefined names, this module will accept +input in the following formats: + +* An entirely lower-case name, such as ``aliceblue``. + +* A name using initial capitals, such as ``AliceBlue``. + +For output which consists of a color specified via a predefined name, +and for functions which perform intermediate conversion to a +predefined name before returning a result in another format, this +module always normalizes such values to be entirely lower-case. + +Mappings of color names +----------------------- + +For each set of defined color names -- HTML 4, CSS 2, CSS 2.1 and CSS +3 -- this module exports two mappings: one of normalized color names +to normalized hexadecimal values, and one of normalized hexadecimal +values to normalized color names. These eight mappings are as follows: + +``html4_names_to_hex`` + Mapping of normalized HTML 4 color names to normalized hexadecimal + values. + +``html4_hex_to_names`` + Mapping of normalized hexadecimal values to normalized HTML 4 + color names. + +``css2_names_to_hex`` + Mapping of normalized CSS 2 color names to normalized hexadecimal + values. Because CSS 2 defines the same set of named colors as HTML + 4, this is merely an alias for ``html4_names_to_hex``. + +``css2_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS 2 color + nams. For the reasons described above, this is merely an alias for + ``html4_hex_to_names``. + +``css21_names_to_hex`` + Mapping of normalized CSS 2.1 color names to normalized + hexadecimal values. This is identical to ``html4_names_to_hex``, + except for one addition: ``orange``. + +``css21_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS 2.1 + color names. As above, this is identical to ``html4_hex_to_names`` + except for the addition of ``orange``. + +``css3_names_to_hex`` + Mapping of normalized CSS3 color names to normalized hexadecimal + values. + +``css3_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS3 color + names. + +Normalization functions +----------------------- + +``normalize_hex(hex_value)`` + Normalize a hexadecimal color value to the following form and + return the result:: + + #[a-f0-9]{6} + + In other words, the following transformations are applied as + needed: + + * If the value contains only three hexadecimal digits, it is + expanded to six. + + * The value is normalized to lower-case. + + If the supplied value cannot be interpreted as a hexadecimal color + value, ``ValueError`` is raised. + + Example: + + >>> normalize_hex('#09c') + '#0099cc' + +Conversions from named colors +----------------------------- + +``name_to_hex(name, spec='css3')`` + Convert a color name to a normalized hexadecimal color value. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Example: + + >>> name_to_hex('deepskyblue') + '#00bfff' + +``name_to_rgb(name, spec='css3')`` + Convert a color name to a 3-tuple of integers suitable for use in + an ``rgb()`` triplet specifying that color. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Example: + + >>> name_to_rgb('navy') + (0, 0, 128) + +``name_to_rgb_percent(name, spec='css3')`` + Convert a color name to a 3-tuple of percentages suitable for use + in an ``rgb()`` triplet specifying that color. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Example: + + >>> name_to_rgb_percent('navy') + ('0%', '0%', '50%') + + +Conversions from hexadecimal values +----------------------------------- + +``hex_to_name(hex_value, spec='css3')`` + Convert a hexadecimal color value to its corresponding normalized + color name, if any such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The hexadecimal value will be normalized before being looked up, + and when no color name for the value is found in the given + specification, ``ValueError`` is raised. + + Example: + + >>> hex_to_name('#000080') + 'navy' + +``hex_to_rgb(hex_value)`` + Convert a hexadecimal color value to a 3-tuple of integers + suitable for use in an ``rgb()`` triplet specifying that color. + + The hexadecimal value will be normalized before being converted. + + Example: + + >>> hex_to_rgb('#000080') + (0, 0, 128) + +``hex_to_rgb_percent(hex_value)`` + Convert a hexadecimal color value to a 3-tuple of percentages + suitable for use in an ``rgb()`` triplet representing that color. + + The hexadecimal value will be normalized before converting. + + Example: + + >>> hex_to_rgb_percent('#ffffff') + ('100%', '100%', '100%') + + +Conversions from integer rgb() triplets +--------------------------------------- + +``rgb_to_name(rgb_triplet, spec='css3')`` + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to its corresponding normalized color name, if any + such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + If there is no matching name, ``ValueError`` is raised. + + Example: + + >>> rgb_to_name((0, 0, 0)) + 'black' + +``rgb_to_hex(rgb_triplet)`` + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to a normalized hexadecimal value for that color. + + Example: + + >>> rgb_to_hex((255, 255, 255)) + '#ffffff' + +``rgb_to_rgb_percent(rgb_triplet)`` + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to a 3-tuple of percentages suitable for use in + representing that color. + + This function makes some trade-offs in terms of the accuracy of + the final representation; for some common integer values, + special-case logic is used to ensure a precise result (e.g., + integer 128 will always convert to '50%', integer 32 will always + convert to '12.5%'), but for all other values a standard Python + ``float`` is used and rounded to two decimal places, which may + result in a loss of precision for some values. + + Examples: + + >>> rgb_to_rgb_percent((255, 255, 255)) + ('100%', '100%', '100%') + >>> rgb_to_rgb_percent((0, 0, 128)) + ('0%', '0%', '50%') + >>> rgb_to_rgb_percent((33, 56, 192)) + ('12.94%', '21.96%', '75.29%') + >>> rgb_to_rgb_percent((64, 32, 16)) + ('25%', '12.5%', '6.25%') + + +Conversions from percentage rgb() triplets +------------------------------------------ + +``rgb_percent_to_name(rgb_percent_triplet, spec='css3')`` + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to its corresponding normalized color name, if any + such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + If there is no matching name, ``ValueError`` is raised. + + Example: + + >>> rgb_percent_to_name(('0%', '0%', '50%')) + 'navy' + +``rgb_percent_to_hex(rgb_percent_triplet)`` + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to a normalized hexadecimal color value for that + color. + + Example: + + >>> rgb_percent_to_hex(('100%', '100%', '0%')) + '#ffff00' + +``rgb_percent_to_rgb(rgb_percent_triplet)`` + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to a 3-tuple of integers suitable for use in + representing that color. + + Some precision may be lost in this conversion. See the note + regarding precision for ``rgb_to_rgb_percent()`` for details; + generally speaking, the following is true for any 3-tuple ``t`` of + integers in the range 0...255 inclusive:: + + t == rgb_percent_to_rgb(rgb_to_rgb_percent(t)) + + Examples: + + >>> rgb_percent_to_rgb(('100%', '100%', '100%')) + (255, 255, 255) + >>> rgb_percent_to_rgb(('0%', '0%', '50%')) + (0, 0, 128) + >>> rgb_percent_to_rgb(('25%', '12.5%', '6.25%')) + (64, 32, 16) + >>> rgb_percent_to_rgb(('12.94%', '21.96%', '75.29%')) + (33, 56, 192) diff --git a/tools/python/stylesheet/webcolors/__init__.py b/tools/python/stylesheet/webcolors/__init__.py new file mode 100644 index 0000000000..40a96afc6f --- /dev/null +++ b/tools/python/stylesheet/webcolors/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/tools/python/stylesheet/webcolors/setup.py b/tools/python/stylesheet/webcolors/setup.py new file mode 100644 index 0000000000..e61b8aa0e7 --- /dev/null +++ b/tools/python/stylesheet/webcolors/setup.py @@ -0,0 +1,21 @@ +import os + +from distutils.core import setup + +setup(name='webcolors', + version='1.3', + description='A library for working with sRGB color specifications as used in HTML and CSS.', + long_description=open(os.path.join(os.path.dirname(__file__), 'README.txt')).read(), + author='James Bennett', + author_email='james@b-list.org', + url='http://www.bitbucket.org/ubernostrum/webcolors/overview/', + py_modules=['webcolors'], + download_url='http://bitbucket.org/ubernostrum/webcolors/downloads/webcolors-1.3.tar.gz', + classifiers=['Development Status :: 5 - Production/Stable', + 'Environment :: Web Environment', + 'Intended Audience :: Developers', + 'License :: OSI Approved :: BSD License', + 'Operating System :: OS Independent', + 'Programming Language :: Python', + 'Topic :: Utilities'], + ) diff --git a/tools/python/stylesheet/webcolors/webcolors.py b/tools/python/stylesheet/webcolors/webcolors.py new file mode 100644 index 0000000000..58bb6b2a44 --- /dev/null +++ b/tools/python/stylesheet/webcolors/webcolors.py @@ -0,0 +1,881 @@ +# -*- coding: utf-8 -*- +""" +A simple library for working with the color names and color codes +defined by the HTML and CSS specifications. + +An overview of HTML and CSS colors +---------------------------------- + +Colors on the Web are specified in `the sRGB color space`_, where each +color is made up of a red component, a green component and a blue +component. This is useful because it maps (fairly) cleanly to the red, +green and blue components of pixels on a computer display, and to the +cone cells of a human eye, which come in three sets roughly +corresponding to the wavelengths of light associated with red, green +and blue. + +`The HTML 4 standard`_ defines two ways to specify sRGB colors: + +* A hash mark ('#') followed by three pairs of hexdecimal digits, + specifying values for red, green and blue components in that order; + for example, ``#0099cc``. Since each pair of hexadecimal digits can + express 256 different values, this allows up to 256**3 or 16,777,216 + unique colors to be specified (though, due to differences in display + technology, not all of these colors may be clearly distinguished on + any given physical display). + +* A set of predefined color names which correspond to specific + hexadecimal values; for example, ``white``. HTML 4 defines sixteen + such colors. + +`The CSS 2 standard`_ allows any valid HTML 4 color specification, and +adds three new ways to specify sRGB colors: + +* A hash mark followed by three hexadecimal digits, which is expanded + into three hexadecimal pairs by repeating each digit; thus ``#09c`` + is equivalent to ``#0099cc``. + +* The string 'rgb', followed by parentheses, between which are three + numeric values each between 0 and 255, inclusive, which are taken to + be the values of the red, green and blue components in that order; + for example, ``rgb(0, 153, 204)``. + +* The same as above, except using percentages instead of numeric + values; for example, ``rgb(0%, 60%, 80%)``. + +`The CSS 2.1 revision`_ does not add any new methods of specifying +sRGB colors, but does add one additional named color. + +`The CSS 3 color module`_ (currently a W3C Candidate Recommendation) +adds one new way to specify sRGB colors: + +* A hue-saturation-lightness triple (HSL), using the construct + ``hsl()``. + +It also adds support for variable opacity of colors, by allowing the +specification of alpha-channel information, through the ``rgba()`` and +``hsla()`` constructs, which are identical to ``rgb()`` and ``hsl()`` +with one exception: a fourth value is supplied, indicating the level +of opacity from ``0.0`` (completely transparent) to ``1.0`` +(completely opaque). Though not technically a color, the keyword +``transparent`` is also made available in lieu of a color value, and +corresponds to ``rgba(0,0,0,0)``. + +Additionally, CSS3 defines a new set of color names; this set is taken +directly from the named colors defined for SVG (Scalable Vector +Graphics) markup, and is a proper superset of the named colors defined +in CSS 2.1. This set also has significant overlap with traditional X11 +color sets as defined by the ``rgb.txt`` file on many Unix and +Unix-like operating systems, though the correspondence is not exact; +the set of X11 colors is not standardized, and the set of CSS3 colors +contains some definitions which diverge significantly from customary +X11 definitions (for example, CSS3's ``green`` is not equivalent to +X11's ``green``; the value which X11 designates ``green`` is +designated ``lime`` in CSS3). + +.. _the sRGB color space: http://www.w3.org/Graphics/Color/sRGB +.. _The HTML 4 standard: http://www.w3.org/TR/html401/types.html#h-6.5 +.. _The CSS 2 standard: http://www.w3.org/TR/REC-CSS2/syndata.html#value-def-color +.. _The CSS 2.1 revision: http://www.w3.org/TR/CSS21/ +.. _The CSS 3 color module: http://www.w3.org/TR/css3-color/ + +What this module supports +------------------------- + +The mappings and functions within this module support the following +methods of specifying sRGB colors, and conversions between them: + +* Six-digit hexadecimal. + +* Three-digit hexadecimal. + +* Integer ``rgb()`` triplet. + +* Percentage ``rgb()`` triplet. + +* Varying selections of predefined color names (see below). + +This module does not support ``hsl()`` triplets, nor does it support +opacity/alpha-channel information via ``rgba()`` or ``hsla()``. + +If you need to convert between RGB-specified colors and HSL-specified +colors, or colors specified via other means, consult `the colorsys +module`_ in the Python standard library, which can perform conversions +amongst several common color spaces. + +.. _the colorsys module: http://docs.python.org/library/colorsys.html + +Normalization +------------- + +For colors specified via hexadecimal values, this module will accept +input in the following formats: + +* A hash mark (#) followed by three hexadecimal digits, where letters + may be upper- or lower-case. + +* A hash mark (#) followed by six hexadecimal digits, where letters + may be upper- or lower-case. + +For output which consists of a color specified via hexadecimal values, +and for functions which perform intermediate conversion to hexadecimal +before returning a result in another format, this module always +normalizes such values to the following format: + +* A hash mark (#) followed by six hexadecimal digits, with letters + forced to lower-case. + +The function ``normalize_hex()`` in this module can be used to perform +this normalization manually if desired; see its documentation for an +explanation of the normalization process. + +For colors specified via predefined names, this module will accept +input in the following formats: + +* An entirely lower-case name, such as ``aliceblue``. + +* A name using initial capitals, such as ``AliceBlue``. + +For output which consists of a color specified via a predefined name, +and for functions which perform intermediate conversion to a +predefined name before returning a result in another format, this +module always normalizes such values to be entirely lower-case. + +Mappings of color names +----------------------- + +For each set of defined color names -- HTML 4, CSS 2, CSS 2.1 and CSS +3 -- this module exports two mappings: one of normalized color names +to normalized hexadecimal values, and one of normalized hexadecimal +values to normalized color names. These eight mappings are as follows: + +``html4_names_to_hex`` + Mapping of normalized HTML 4 color names to normalized hexadecimal + values. + +``html4_hex_to_names`` + Mapping of normalized hexadecimal values to normalized HTML 4 + color names. + +``css2_names_to_hex`` + Mapping of normalized CSS 2 color names to normalized hexadecimal + values. Because CSS 2 defines the same set of named colors as HTML + 4, this is merely an alias for ``html4_names_to_hex``. + +``css2_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS 2 color + nams. For the reasons described above, this is merely an alias for + ``html4_hex_to_names``. + +``css21_names_to_hex`` + Mapping of normalized CSS 2.1 color names to normalized + hexadecimal values. This is identical to ``html4_names_to_hex``, + except for one addition: ``orange``. + +``css21_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS 2.1 + color names. As above, this is identical to ``html4_hex_to_names`` + except for the addition of ``orange``. + +``css3_names_to_hex`` + Mapping of normalized CSS3 color names to normalized hexadecimal + values. + +``css3_hex_to_names`` + Mapping of normalized hexadecimal values to normalized CSS3 color + names. + +""" + +import math +import re +from hashlib import md5 + + +def _reversedict(d): + """ + Internal helper for generating reverse mappings; given a + dictionary, returns a new dictionary with keys and values swapped. + + """ + return dict(zip(d.values(), d.keys())) + +HEX_COLOR_RE = re.compile(r'^#([a-fA-F0-9]{3}|[a-fA-F0-9]{6})$') + +SUPPORTED_SPECIFICATIONS = ('html4', 'css2', 'css21', 'css3') + + +###################################################################### +# Mappings of color names to normalized hexadecimal color values. +###################################################################### + + +html4_names_to_hex = { + 'aqua': '#00ffff', + 'black': '#000000', + 'blue': '#0000ff', + 'fuchsia': '#ff00ff', + 'green': '#008000', + 'grey': '#808080', + 'lime': '#00ff00', + 'maroon': '#800000', + 'navy': '#000080', + 'olive': '#808000', + 'purple': '#800080', + 'red': '#ff0000', + 'silver': '#c0c0c0', + 'teal': '#008080', + 'white': '#ffffff', + 'yellow': '#ffff00' +} + +css2_names_to_hex = html4_names_to_hex + +css21_names_to_hex = dict(html4_names_to_hex, orange='#ffa500') + +css3_names_to_hex = { + 'aliceblue': '#f0f8ff', + 'antiquewhite': '#faebd7', + 'aqua': '#00ffff', + 'aquamarine': '#7fffd4', + 'azure': '#f0ffff', + 'beige': '#f5f5dc', + 'bisque': '#ffe4c4', + 'black': '#000000', + 'blanchedalmond': '#ffebcd', + 'blue': '#0000ff', + 'blueviolet': '#8a2be2', + 'brown': '#a52a2a', + 'burlywood': '#deb887', + 'cadetblue': '#5f9ea0', + 'chartreuse': '#7fff00', + 'chocolate': '#d2691e', + 'coral': '#ff7f50', + 'cornflowerblue': '#6495ed', + 'cornsilk': '#fff8dc', + 'crimson': '#dc143c', + 'cyan': '#00ffff', + 'darkblue': '#00008b', + 'darkcyan': '#008b8b', + 'darkgoldenrod': '#b8860b', + 'darkgray': '#a9a9a9', + 'darkgrey': '#a9a9a9', + 'darkgreen': '#006400', + 'darkkhaki': '#bdb76b', + 'darkmagenta': '#8b008b', + 'darkolivegreen': '#556b2f', + 'darkorange': '#ff8c00', + 'darkorchid': '#9932cc', + 'darkred': '#8b0000', + 'darksalmon': '#e9967a', + 'darkseagreen': '#8fbc8f', + 'darkslateblue': '#483d8b', + 'darkslategray': '#2f4f4f', + 'darkslategrey': '#2f4f4f', + 'darkturquoise': '#00ced1', + 'darkviolet': '#9400d3', + 'deeppink': '#ff1493', + 'deepskyblue': '#00bfff', + 'dimgray': '#696969', + 'dimgrey': '#696969', + 'dodgerblue': '#1e90ff', + 'firebrick': '#b22222', + 'floralwhite': '#fffaf0', + 'forestgreen': '#228b22', + 'fuchsia': '#ff00ff', + 'gainsboro': '#dcdcdc', + 'ghostwhite': '#f8f8ff', + 'gold': '#ffd700', + 'goldenrod': '#daa520', + 'gray': '#808080', + 'grey': '#808080', + 'green': '#008000', + 'greenyellow': '#adff2f', + 'honeydew': '#f0fff0', + 'hotpink': '#ff69b4', + 'indianred': '#cd5c5c', + 'indigo': '#4b0082', + 'ivory': '#fffff0', + 'khaki': '#f0e68c', + 'lavender': '#e6e6fa', + 'lavenderblush': '#fff0f5', + 'lawngreen': '#7cfc00', + 'lemonchiffon': '#fffacd', + 'lightblue': '#add8e6', + 'lightcoral': '#f08080', + 'lightcyan': '#e0ffff', + 'lightgoldenrodyellow': '#fafad2', + 'lightgray': '#d3d3d3', + 'lightgrey': '#d3d3d3', + 'lightgreen': '#90ee90', + 'lightpink': '#ffb6c1', + 'lightsalmon': '#ffa07a', + 'lightseagreen': '#20b2aa', + 'lightskyblue': '#87cefa', + 'lightslategray': '#778899', + 'lightslategrey': '#778899', + 'lightsteelblue': '#b0c4de', + 'lightyellow': '#ffffe0', + 'lime': '#00ff00', + 'limegreen': '#32cd32', + 'linen': '#faf0e6', + 'magenta': '#ff00ff', + 'maroon': '#800000', + 'mediumaquamarine': '#66cdaa', + 'mediumblue': '#0000cd', + 'mediumorchid': '#ba55d3', + 'mediumpurple': '#9370d8', + 'mediumseagreen': '#3cb371', + 'mediumslateblue': '#7b68ee', + 'mediumspringgreen': '#00fa9a', + 'mediumturquoise': '#48d1cc', + 'mediumvioletred': '#c71585', + 'midnightblue': '#191970', + 'mintcream': '#f5fffa', + 'mistyrose': '#ffe4e1', + 'moccasin': '#ffe4b5', + 'navajowhite': '#ffdead', + 'navy': '#000080', + 'oldlace': '#fdf5e6', + 'olive': '#808000', + 'olivedrab': '#6b8e23', + 'orange': '#ffa500', + 'orangered': '#ff4500', + 'orchid': '#da70d6', + 'palegoldenrod': '#eee8aa', + 'palegreen': '#98fb98', + 'paleturquoise': '#afeeee', + 'palevioletred': '#d87093', + 'papayawhip': '#ffefd5', + 'peachpuff': '#ffdab9', + 'peru': '#cd853f', + 'pink': '#ffc0cb', + 'plum': '#dda0dd', + 'powderblue': '#b0e0e6', + 'purple': '#800080', + 'red': '#ff0000', + 'rosybrown': '#bc8f8f', + 'royalblue': '#4169e1', + 'saddlebrown': '#8b4513', + 'salmon': '#fa8072', + 'sandybrown': '#f4a460', + 'seagreen': '#2e8b57', + 'seashell': '#fff5ee', + 'sienna': '#a0522d', + 'silver': '#c0c0c0', + 'skyblue': '#87ceeb', + 'slateblue': '#6a5acd', + 'slategray': '#708090', + 'slategrey': '#708090', + 'snow': '#fffafa', + 'springgreen': '#00ff7f', + 'steelblue': '#4682b4', + 'tan': '#d2b48c', + 'teal': '#008080', + 'thistle': '#d8bfd8', + 'tomato': '#ff6347', + 'turquoise': '#40e0d0', + 'violet': '#ee82ee', + 'wheat': '#f5deb3', + 'white': '#ffffff', + 'whitesmoke': '#f5f5f5', + 'yellow': '#ffff00', + 'yellowgreen': '#9acd32', +} + + +###################################################################### +# Mappings of normalized hexadecimal color values to color names. +###################################################################### + + +html4_hex_to_names = _reversedict(html4_names_to_hex) + +css2_hex_to_names = html4_hex_to_names + +css21_hex_to_names = _reversedict(css21_names_to_hex) + +css3_hex_to_names = _reversedict(css3_names_to_hex) + + +###################################################################### +# Normalization routines. +###################################################################### + + +def normalize_hex(hex_value): + """ + Normalize a hexadecimal color value to the following form and + return the result:: + + #[a-f0-9]{6} + + In other words, the following transformations are applied as + needed: + + * If the value contains only three hexadecimal digits, it is + expanded to six. + + * The value is normalized to lower-case. + + If the supplied value cannot be interpreted as a hexadecimal color + value, ``ValueError`` is raised. + + Examples: + + >>> normalize_hex('#09c') + '#0099cc' + >>> normalize_hex('#0099cc') + '#0099cc' + >>> normalize_hex('#09C') + '#0099cc' + >>> normalize_hex('#0099CC') + '#0099cc' + >>> normalize_hex('0099cc') + Traceback (most recent call last): + ... + ValueError: '0099cc' is not a valid hexadecimal color value. + >>> normalize_hex('#0099QX') + Traceback (most recent call last): + ... + ValueError: '#0099QX' is not a valid hexadecimal color value. + >>> normalize_hex('foobarbaz') + Traceback (most recent call last): + ... + ValueError: 'foobarbaz' is not a valid hexadecimal color value. + >>> normalize_hex('#0') + Traceback (most recent call last): + ... + ValueError: '#0' is not a valid hexadecimal color value. + + """ + try: + hex_digits = HEX_COLOR_RE.match(hex_value).groups()[0] + except AttributeError: + raise ValueError("'%s' is not a valid hexadecimal color value." % hex_value) + if len(hex_digits) == 3: + hex_digits = ''.join(map(lambda s: 2 * s, hex_digits)) + return '#%s' % hex_digits.lower() + + +###################################################################### +# Conversions from color names to various formats. +###################################################################### + + +def name_to_hex(name, spec='css3'): + """ + Convert a color name to a normalized hexadecimal color value. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Examples: + + >>> name_to_hex('deepskyblue') + '#00bfff' + >>> name_to_hex('DeepSkyBlue') + '#00bfff' + >>> name_to_hex('white', spec='html4') + '#ffffff' + >>> name_to_hex('white', spec='css2') + '#ffffff' + >>> name_to_hex('white', spec='css21') + '#ffffff' + >>> name_to_hex('white', spec='css3') + '#ffffff' + >>> name_to_hex('white', spec='css4') + Traceback (most recent call last): + ... + TypeError: 'css4' is not a supported specification for color name lookups; supported specifications are: html4, css2, css21, css3. + >>> name_to_hex('deepskyblue', spec='css2') + Traceback (most recent call last): + ... + ValueError: 'deepskyblue' is not defined as a named color in css2. + + """ + if spec not in SUPPORTED_SPECIFICATIONS: + raise TypeError("'%s' is not a supported specification for color name lookups; supported specifications are: %s." % (spec, + ', '.join(SUPPORTED_SPECIFICATIONS))) + normalized = name.lower() + try: + hex_value = globals()['%s_names_to_hex' % spec][normalized] + except KeyError: + raise ValueError("'%s' is not defined as a named color in %s." % (name, spec)) + return hex_value + + +def name_to_rgb(name, spec='css3'): + """ + Convert a color name to a 3-tuple of integers suitable for use in + an ``rgb()`` triplet specifying that color. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Examples: + + >>> name_to_rgb('navy') + (0, 0, 128) + >>> name_to_rgb('cadetblue') + (95, 158, 160) + >>> name_to_rgb('cadetblue', spec='html4') + Traceback (most recent call last): + ... + ValueError: 'cadetblue' is not defined as a named color in html4. + + """ + return hex_to_rgb(name_to_hex(name, spec=spec)) + + +def name_to_rgb_percent(name, spec='css3'): + """ + Convert a color name to a 3-tuple of percentages suitable for use + in an ``rgb()`` triplet specifying that color. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The color name will be normalized to lower-case before being + looked up, and when no color of that name exists in the given + specification, ``ValueError`` is raised. + + Examples: + + >>> name_to_rgb_percent('white') + ('100%', '100%', '100%') + >>> name_to_rgb_percent('navy') + ('0%', '0%', '50%') + >>> name_to_rgb_percent('goldenrod') + ('85.49%', '64.71%', '12.5%') + + """ + return rgb_to_rgb_percent(name_to_rgb(name, spec=spec)) + + +###################################################################### +# Conversions from hexadecimal color values to various formats. +###################################################################### + + +def hex_to_name(hex_value, spec='css3'): + """ + Convert a hexadecimal color value to its corresponding normalized + color name, if any such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + The hexadecimal value will be normalized before being looked up, + and when no color name for the value is found in the given + specification, ``ValueError`` is raised. + + Examples: + + >>> hex_to_name('#000080') + 'navy' + >>> hex_to_name('#000080', spec='html4') + 'navy' + >>> hex_to_name('#000080', spec='css2') + 'navy' + >>> hex_to_name('#000080', spec='css21') + 'navy' + >>> hex_to_name('#8b4513') + 'saddlebrown' + >>> hex_to_name('#8b4513', spec='html4') + Traceback (most recent call last): + ... + ValueError: '#8b4513' has no defined color name in html4. + >>> hex_to_name('#8b4513', spec='css4') + Traceback (most recent call last): + ... + TypeError: 'css4' is not a supported specification for color name lookups; supported specifications are: html4, css2, css21, css3. + + """ + if spec not in SUPPORTED_SPECIFICATIONS: + raise TypeError("'%s' is not a supported specification for color name lookups; supported specifications are: %s." % (spec, + ', '.join(SUPPORTED_SPECIFICATIONS))) + normalized = normalize_hex(hex_value) + try: + name = globals()['%s_hex_to_names' % spec][normalized] + except KeyError: + raise ValueError("'%s' has no defined color name in %s." % (hex_value, spec)) + return name + + +def hex_to_color_name(hex_value): + hex_value = hex_value.strip('#') + hex_value = "#" + "0" * (6 - len(hex_value)) + hex_value + try: + return hex_to_name(hex_value) + except ValueError: + return hex_value + + +def hex_to_rgb(hex_value): + """ + Convert a hexadecimal color value to a 3-tuple of integers + suitable for use in an ``rgb()`` triplet specifying that color. + + The hexadecimal value will be normalized before being converted. + + Examples: + + >>> hex_to_rgb('#000080') + (0, 0, 128) + >>> hex_to_rgb('#ffff00') + (255, 255, 0) + >>> hex_to_rgb('#f00') + (255, 0, 0) + >>> hex_to_rgb('#deb887') + (222, 184, 135) + + """ + hex_digits = normalize_hex(hex_value) + return tuple(map(lambda s: int(s, 16), + (hex_digits[1:3], hex_digits[3:5], hex_digits[5:7]))) + + +def hex_to_rgb_percent(hex_value): + """ + Convert a hexadecimal color value to a 3-tuple of percentages + suitable for use in an ``rgb()`` triplet representing that color. + + The hexadecimal value will be normalized before converting. + + Examples: + + >>> hex_to_rgb_percent('#ffffff') + ('100%', '100%', '100%') + >>> hex_to_rgb_percent('#000080') + ('0%', '0%', '50%') + + """ + return rgb_to_rgb_percent(hex_to_rgb(hex_value)) + + +###################################################################### +# Conversions from integer rgb() triplets to various formats. +###################################################################### + + +def rgb_to_name(rgb_triplet, spec='css3'): + """ + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to its corresponding normalized color name, if any + such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + If there is no matching name, ``ValueError`` is raised. + + Examples: + + >>> rgb_to_name((0, 0, 0)) + 'black' + >>> rgb_to_name((0, 0, 128)) + 'navy' + >>> rgb_to_name((95, 158, 160)) + 'cadetblue' + + """ + return hex_to_name(rgb_to_hex(rgb_triplet), spec=spec) + + +def rgb_to_hex(rgb_triplet): + """ + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to a normalized hexadecimal value for that color. + + Examples: + + >>> rgb_to_hex((255, 255, 255)) + '#ffffff' + >>> rgb_to_hex((0, 0, 128)) + '#000080' + >>> rgb_to_hex((33, 56, 192)) + '#2138c0' + + """ + return '#%02x%02x%02x' % rgb_triplet + + +def rgb_to_rgb_percent(rgb_triplet): + """ + Convert a 3-tuple of integers, suitable for use in an ``rgb()`` + color triplet, to a 3-tuple of percentages suitable for use in + representing that color. + + This function makes some trade-offs in terms of the accuracy of + the final representation; for some common integer values, + special-case logic is used to ensure a precise result (e.g., + integer 128 will always convert to '50%', integer 32 will always + convert to '12.5%'), but for all other values a standard Python + ``float`` is used and rounded to two decimal places, which may + result in a loss of precision for some values. + + Examples: + + >>> rgb_to_rgb_percent((255, 255, 255)) + ('100%', '100%', '100%') + >>> rgb_to_rgb_percent((0, 0, 128)) + ('0%', '0%', '50%') + >>> rgb_to_rgb_percent((33, 56, 192)) + ('12.94%', '21.96%', '75.29%') + >>> rgb_to_rgb_percent((64, 32, 16)) + ('25%', '12.5%', '6.25%') + + """ + # In order to maintain precision for common values, + # 256 / 2**n is special-cased for values of n + # from 0 through 4, as well as 0 itself. + specials = {255: '100%', 128: '50%', 64: '25%', + 32: '12.5%', 16: '6.25%', 0: '0%'} + return tuple(map(lambda d: specials.get(d, '%.02f%%' % ((d / 255.0) * 100)), + rgb_triplet)) + + +###################################################################### +# Conversions from percentage rgb() triplets to various formats. +###################################################################### + + +def rgb_percent_to_name(rgb_percent_triplet, spec='css3'): + """ + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to its corresponding normalized color name, if any + such name exists. + + The optional keyword argument ``spec`` determines which + specification's list of color names will be used; valid values are + ``html4``, ``css2``, ``css21`` and ``css3``, and the default is + ``css3``. + + If there is no matching name, ``ValueError`` is raised. + + Examples: + + >>> rgb_percent_to_name(('0%', '0%', '0%')) + 'black' + >>> rgb_percent_to_name(('0%', '0%', '50%')) + 'navy' + >>> rgb_percent_to_name(('85.49%', '64.71%', '12.5%')) + 'goldenrod' + + """ + return rgb_to_name(rgb_percent_to_rgb(rgb_percent_triplet), spec=spec) + + +def rgb_percent_to_hex(rgb_percent_triplet): + """ + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to a normalized hexadecimal color value for that + color. + + Examples: + + >>> rgb_percent_to_hex(('100%', '100%', '0%')) + '#ffff00' + >>> rgb_percent_to_hex(('0%', '0%', '50%')) + '#000080' + >>> rgb_percent_to_hex(('85.49%', '64.71%', '12.5%')) + '#daa520' + + """ + return rgb_to_hex(rgb_percent_to_rgb(rgb_percent_triplet)) + + +def _percent_to_integer(percent): + """ + Internal helper for converting a percentage value to an integer + between 0 and 255 inclusive. + + """ + num = float(percent.split('%')[0]) / 100.0 * 255 + e = num - math.floor(num) + return e < 0.5 and int(math.floor(num)) or int(math.ceil(num)) + + +def rgb_percent_to_rgb(rgb_percent_triplet): + """ + Convert a 3-tuple of percentages, suitable for use in an ``rgb()`` + color triplet, to a 3-tuple of integers suitable for use in + representing that color. + + Some precision may be lost in this conversion. See the note + regarding precision for ``rgb_to_rgb_percent()`` for details; + generally speaking, the following is true for any 3-tuple ``t`` of + integers in the range 0...255 inclusive:: + + t == rgb_percent_to_rgb(rgb_to_rgb_percent(t)) + + Examples: + + >>> rgb_percent_to_rgb(('100%', '100%', '100%')) + (255, 255, 255) + >>> rgb_percent_to_rgb(('0%', '0%', '50%')) + (0, 0, 128) + >>> rgb_percent_to_rgb(('25%', '12.5%', '6.25%')) + (64, 32, 16) + >>> rgb_percent_to_rgb(('12.94%', '21.96%', '75.29%')) + (33, 56, 192) + + """ + return tuple(map(_percent_to_integer, rgb_percent_triplet)) + + +def whatever_to_rgb(string): + """ + Converts CSS3 color or a hex into rgb triplet; hash of string if fails. + """ + string = string.strip().lower() + try: + return name_to_rgb(string) + except ValueError: + try: + return hex_to_rgb(string) + except ValueError: + try: + if string[:3] == "rgb": + return tuple([float(i) for i in string[4:-1].split(",")][0:3]) + except: + return hex_to_rgb("#" + md5(string).hexdigest()[:6]) + + +def whatever_to_hex(string): + if type(string) == tuple: + return cairo_to_hex(string) + return rgb_to_hex(whatever_to_rgb(string)) + + +def whatever_to_cairo(string): + a = whatever_to_rgb(string) + return a[0] / 255., a[1] / 255., a[2] / 255., + + +def cairo_to_hex(cairo): + return rgb_to_hex((cairo[0] * 255, cairo[1] * 255, cairo[2] * 255,)) + + +if __name__ == '__main__': + import doctest + doctest.testmod()