# -*- coding: utf-8 -*- # # This file is part of the python-chess library. # Copyright (C) 2016-2017 Niklas Fiekas # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # Piece vector graphics are copyright (C) Colin M.L. Burnett # and also licensed under the # GNU General Public License. from __future__ import division import chess import math import xml.etree.ElementTree as ET try: import backport_collections as collections except ImportError: import collections SQUARE_SIZE = 45 PIECES = { "b": """""", "k": """""", "n": """""", "p": """""", "q": """""", "r": """""", "B": """""", "K": """""", "N": """""", "P": """""", "Q": """""", "R": """""" } XX = """""" ARROWHEAD = """""" CHECK_GRADIENT = """""" DEFAULT_COLORS = { "square light": "#ffce9e", "square dark": "#d18b47", "square dark lastmove": "#aaa23b", "square light lastmove": "#cdd16a", } DEFAULT_STYLE = """ .check { fill: url(#check_gradient); } """ class Arrow(collections.namedtuple("Arrow", "tail head")): """Details of an arrow to be drawn.""" __slots__ = () def _svg(viewbox, size): svg = ET.Element("svg", { "xmlns": "http://www.w3.org/2000/svg", "version": "1.1", "xmlns:xlink": "http://www.w3.org/1999/xlink", "viewBox": "0 0 %d %d" % (viewbox, viewbox), }) if size is not None: svg.set("width", str(size)) svg.set("height", str(size)) return svg def _text(content, x, y, width, height): t = ET.Element("text", { "x": str(x + width // 2), "y": str(y + height // 2), "font-size": str(max(1, int(min(width, height) * 0.7))), "text-anchor": "middle", "alignment-baseline": "middle", }) t.text = content return t def piece(piece, size=None): """ Renders the given :class:`chess.Piece` as an SVG image. >>> import chess >>> import chess.svg >>> >>> from IPython.core.display import SVG >>> >>> SVG(chess.svg.piece(chess.Piece.from_symbol("R"))) # doctest: +SKIP .. image:: ../docs/wR.svg """ svg = _svg(SQUARE_SIZE, size) svg.append(ET.fromstring(PIECES[piece.symbol()])) return ET.tostring(svg).decode("utf-8") def board(board=None, squares=None, flipped=False, coordinates=True, lastmove=None, check=None, arrows=(), size=None, style=None): """ Renders a board with pieces and/or selected squares as an SVG image. :param board: A :class:`chess.BaseBoard` for a chessboard with pieces or ``None`` (the default) for a chessboard without pieces. :param squares: A :class:`chess.SquareSet` with selected squares. :param flipped: Pass ``True`` to flip the board. :param coordinates: Pass ``False`` to disable coordinates in the margin. :param lastmove: A :class:`chess.Move` to be highlighted. :param check: A square to be marked as check. :param arrows: A list of :class:`~chess.svg.Arrow` objects like ``[chess.svg.Arrow(chess.E2, chess.E4)]`` or a list of tuples like ``[(chess.E2, chess.E4)]``. An arrow from a square pointing to the same square is drawn as a circle, like ``[(chess.E2, chess.E2)]``. :param size: The size of the image in pixels (e.g., ``400`` for a 400 by 400 board) or ``None`` (the default) for no size limit. :param style: A CSS stylesheet to include in the SVG image. >>> import chess >>> import chess.svg >>> >>> from IPython.core.display import SVG >>> >>> board = chess.Board("8/8/8/8/4N3/8/8/8 w - - 0 1") >>> squares = board.attacks(chess.E4) >>> SVG(chess.svg.board(board=board, squares=squares)) # doctest: +SKIP .. image:: ../docs/Ne4.svg """ margin = 20 if coordinates else 0 svg = _svg(8 * SQUARE_SIZE + 2 * margin, size) ET.SubElement(svg, "style").text = DEFAULT_STYLE if style is None else style defs = ET.SubElement(svg, "defs") if board: for color in chess.COLORS: for piece_type in chess.PIECE_TYPES: if board.pieces_mask(piece_type, color): defs.append(ET.fromstring(PIECES[chess.Piece(piece_type, color).symbol()])) if squares: defs.append(ET.fromstring(XX)) if arrows: defs.append(ET.fromstring(ARROWHEAD)) if check is not None: defs.append(ET.fromstring(CHECK_GRADIENT)) for square, bb in enumerate(chess.BB_SQUARES): file_index = chess.square_file(square) rank_index = chess.square_rank(square) x = (file_index if not flipped else 7 - file_index) * SQUARE_SIZE + margin y = (7 - rank_index if not flipped else rank_index) * SQUARE_SIZE + margin cls = ["square", "light" if chess.BB_LIGHT_SQUARES & bb else "dark"] if lastmove and square in [lastmove.from_square, lastmove.to_square]: cls.append("lastmove") fill_color = DEFAULT_COLORS[" ".join(cls)] cls.append(chess.SQUARE_NAMES[square]) # Fill color is required for renderers without