""" weasyprint.images ----------------- Fetch and decode images in various formats. """ import math from io import BytesIO from xml.etree import ElementTree import cairocffi import cairosvg.parser import cairosvg.surface from .layout.percentages import percentage from .logger import LOGGER from .urls import URLFetchingError, fetch try: from cairocffi import pixbuf except OSError: pixbuf = None assert cairosvg.surface.cairo is cairocffi, ( 'CairoSVG is using pycairo instead of cairocffi. ' 'Make sure it is not imported before WeasyPrint.') # Map values of the image-rendering property to cairo FILTER values: # Values are normalized to lower case. IMAGE_RENDERING_TO_FILTER = { 'auto': cairocffi.FILTER_BILINEAR, 'crisp-edges': cairocffi.FILTER_BEST, 'pixelated': cairocffi.FILTER_NEAREST, } class ImageLoadingError(ValueError): """An error occured when loading an image. The image data is probably corrupted or in an invalid format. """ @classmethod def from_exception(cls, exception): name = type(exception).__name__ value = str(exception) return cls('%s: %s' % (name, value) if value else name) class RasterImage: def __init__(self, image_surface): self.image_surface = image_surface self._intrinsic_width = image_surface.get_width() self._intrinsic_height = image_surface.get_height() self.intrinsic_ratio = ( self._intrinsic_width / self._intrinsic_height if self._intrinsic_height != 0 else float('inf')) def get_intrinsic_size(self, image_resolution, _font_size): # Raster images are affected by the 'image-resolution' property. return (self._intrinsic_width / image_resolution, self._intrinsic_height / image_resolution) def draw(self, context, concrete_width, concrete_height, image_rendering): has_size = ( concrete_width > 0 and concrete_height > 0 and self._intrinsic_width > 0 and self._intrinsic_height > 0 ) if not has_size: return # Use the real intrinsic size here, # not affected by 'image-resolution'. context.scale(concrete_width / self._intrinsic_width, concrete_height / self._intrinsic_height) context.set_source_surface(self.image_surface) context.get_source().set_filter( IMAGE_RENDERING_TO_FILTER[image_rendering]) context.paint() class ScaledSVGSurface(cairosvg.surface.SVGSurface): """ Have the cairo Surface object have intrinsic dimension in pixels instead of points. """ @property def device_units_per_user_units(self): scale = super().device_units_per_user_units return scale / 0.75 class FakeSurface: """Fake CairoSVG surface used to get SVG attributes.""" context_height = 0 context_width = 0 font_size = 12 dpi = 96 class SVGImage: def __init__(self, svg_data, base_url, url_fetcher): # Don’t pass data URIs to CairoSVG. # They are useless for relative URIs anyway. self._base_url = ( base_url if not base_url.lower().startswith('data:') else None) self._svg_data = svg_data self._url_fetcher = url_fetcher try: self._tree = ElementTree.fromstring(self._svg_data) except Exception as e: raise ImageLoadingError.from_exception(e) def _cairosvg_url_fetcher(self, src, mimetype): data = self._url_fetcher(src) if 'string' in data: return data['string'] return data['file_obj'].read() def get_intrinsic_size(self, _image_resolution, font_size): # Vector images may be affected by the font size. fake_surface = FakeSurface() fake_surface.font_size = font_size # Percentages don't provide an intrinsic size, we transform percentages # into 0 using a (0, 0) context size: # http://www.w3.org/TR/SVG/coords.html#IntrinsicSizing self._width = cairosvg.surface.size( fake_surface, self._tree.get('width')) self._height = cairosvg.surface.size( fake_surface, self._tree.get('height')) _, _, viewbox = cairosvg.surface.node_format(fake_surface, self._tree) self._intrinsic_width = self._width or None self._intrinsic_height = self._height or None self.intrinsic_ratio = None if viewbox: if self._width and self._height: self.intrinsic_ratio = self._width / self._height else: if viewbox[2] and viewbox[3]: self.intrinsic_ratio = viewbox[2] / viewbox[3] if self._width: self._intrinsic_height = ( self._width / self.intrinsic_ratio) elif self._height: self._intrinsic_width = ( self._height * self.intrinsic_ratio) elif self._width and self._height: self.intrinsic_ratio = self._width / self._height return self._intrinsic_width, self._intrinsic_height def draw(self, context, concrete_width, concrete_height, _image_rendering): try: svg = ScaledSVGSurface( cairosvg.parser.Tree( bytestring=self._svg_data, url=self._base_url, url_fetcher=self._cairosvg_url_fetcher), output=None, dpi=96, output_width=concrete_width, output_height=concrete_height) if svg.width and svg.height: context.scale( concrete_width / svg.width, concrete_height / svg.height) context.set_source_surface(svg.cairo) context.paint() except Exception as e: LOGGER.error( 'Failed to draw an SVG image at %s : %s', self._base_url, e) def get_image_from_uri(cache, url_fetcher, url, forced_mime_type=None): """Get a cairo Pattern from an image URI.""" missing = object() image = cache.get(url, missing) if image is not missing: return image try: with fetch(url_fetcher, url) as result: if 'string' in result: string = result['string'] else: string = result['file_obj'].read() mime_type = forced_mime_type or result['mime_type'] if mime_type == 'image/svg+xml': # No fallback for XML-based mimetypes as defined by MIME # Sniffing Standard, see https://mimesniff.spec.whatwg.org/ image = SVGImage(string, url, url_fetcher) else: # Try to rely on given mimetype try: if mime_type == 'image/png': try: surface = cairocffi.ImageSurface.create_from_png( BytesIO(string)) except Exception as exception: raise ImageLoadingError.from_exception(exception) else: image = RasterImage(surface) else: image = None except ImageLoadingError: image = None # Relying on mimetype didn't work, give the image to GDK-Pixbuf if not image: if pixbuf is None: raise ImageLoadingError( 'Could not load GDK-Pixbuf. PNG and SVG are ' 'the only image formats available.') try: image = SVGImage(string, url, url_fetcher) except BaseException: try: surface, format_name = ( pixbuf.decode_to_image_surface(string)) except pixbuf.ImageLoadingError as exception: raise ImageLoadingError(str(exception)) if format_name == 'jpeg': surface.set_mime_data('image/jpeg', string) image = RasterImage(surface) except (URLFetchingError, ImageLoadingError) as exc: LOGGER.error('Failed to load image at "%s" (%s)', url, exc) image = None cache[url] = image return image def process_color_stops(gradient_line_size, positions): """ Gradient line size: distance between the starting point and ending point. Positions: list of None, or Dimension in px or %. 0 is the starting point, 1 the ending point. http://dev.w3.org/csswg/css-images-3/#color-stop-syntax Return processed color stops, as a list of floats in px. """ positions = [ percentage(position, gradient_line_size) for position in positions] # First and last default to 100% if positions[0] is None: positions[0] = 0 if positions[-1] is None: positions[-1] = gradient_line_size # Make sure positions are increasing. previous_pos = positions[0] for i, position in enumerate(positions): if position is not None: if position < previous_pos: positions[i] = previous_pos else: previous_pos = position # Assign missing values previous_i = -1 for i, position in enumerate(positions): if position is not None: base = positions[previous_i] increment = (position - base) / (i - previous_i) for j in range(previous_i + 1, i): positions[j] = base + j * increment previous_i = i return positions def normalize_stop_postions(positions): """Normalize to [0..1].""" first = positions[0] last = positions[-1] total_length = last - first if total_length != 0: positions = [(pos - first) / total_length for pos in positions] else: positions = [0 for _ in positions] return first, last, positions def gradient_average_color(colors, positions): """ http://dev.w3.org/csswg/css-images-3/#find-the-average-color-of-a-gradient """ nb_stops = len(positions) assert nb_stops > 1 assert nb_stops == len(colors) total_length = positions[-1] - positions[0] if total_length == 0: positions = list(range(nb_stops)) total_length = nb_stops - 1 premul_r = [r * a for r, g, b, a in colors] premul_g = [g * a for r, g, b, a in colors] premul_b = [b * a for r, g, b, a in colors] alpha = [a for r, g, b, a in colors] result_r = result_g = result_b = result_a = 0 total_weight = 2 * total_length for i, position in enumerate(positions[1:], 1): weight = (position - positions[i - 1]) / total_weight for j in (i - 1, i): result_r += premul_r[j] * weight result_g += premul_g[j] * weight result_b += premul_b[j] * weight result_a += alpha[j] * weight # Un-premultiply: return (result_r / result_a, result_g / result_a, result_b / result_a, result_a) if result_a != 0 else (0, 0, 0, 0) PATTERN_TYPES = dict( linear=cairocffi.LinearGradient, radial=cairocffi.RadialGradient, solid=cairocffi.SolidPattern) class Gradient: def __init__(self, color_stops, repeating): assert color_stops #: List of (r, g, b, a), list of Dimension self.colors = [color for color, position in color_stops] self.stop_positions = [position for color, position in color_stops] #: bool self.repeating = repeating def get_intrinsic_size(self, _image_resolution, _font_size): # Gradients are not affected by image resolution, parent or font size. return None, None intrinsic_ratio = None def draw(self, context, concrete_width, concrete_height, _image_rendering): scale_y, type_, init, stop_positions, stop_colors = self.layout( concrete_width, concrete_height, context.user_to_device_distance) context.scale(1, scale_y) pattern = PATTERN_TYPES[type_](*init) for position, color in zip(stop_positions, stop_colors): pattern.add_color_stop_rgba(position, *color) pattern.set_extend(cairocffi.EXTEND_REPEAT if self.repeating else cairocffi.EXTEND_PAD) context.set_source(pattern) context.paint() def layout(self, width, height, user_to_device_distance): """width, height: Gradient box. Top-left is at coordinates (0, 0). user_to_device_distance: a (dx, dy) -> (ddx, ddy) function Returns (scale_y, type_, init, positions, colors). scale_y: float, used for ellipses radial gradients. 1 otherwise. positions: list of floats in [0..1]. 0 at the starting point, 1 at the ending point. colors: list of (r, g, b, a) type_ is either: 'solid': init is (r, g, b, a). positions and colors are empty. 'linear': init is (x0, y0, x1, y1) coordinates of the starting and ending points. 'radial': init is (cx0, cy0, radius0, cx1, cy1, radius1) coordinates of the starting end ending circles """ raise NotImplementedError class LinearGradient(Gradient): def __init__(self, color_stops, direction, repeating): Gradient.__init__(self, color_stops, repeating) #: ('corner', keyword) or ('angle', radians) self.direction_type, self.direction = direction def layout(self, width, height, user_to_device_distance): if len(self.colors) == 1: return 1, 'solid', self.colors[0], [], [] # (dx, dy) is the unit vector giving the direction of the gradient. # Positive dx: right, positive dy: down. if self.direction_type == 'corner': factor_x, factor_y = { 'top_left': (-1, -1), 'top_right': (1, -1), 'bottom_left': (-1, 1), 'bottom_right': (1, 1)}[self.direction] diagonal = math.hypot(width, height) # Note the direction swap: dx based on height, dy based on width # The gradient line is perpendicular to a diagonal. dx = factor_x * height / diagonal dy = factor_y * width / diagonal else: angle = self.direction # 0 upwards, then clockwise dx = math.sin(angle) dy = -math.cos(angle) # Distance between center and ending point, # ie. half of between the starting point and ending point: distance = abs(width * dx) + abs(height * dy) positions = process_color_stops(distance, self.stop_positions) first, last, positions = normalize_stop_postions(positions) device_per_user_units = math.hypot(*user_to_device_distance(dx, dy)) if (last - first) * device_per_user_units < len(positions): if self.repeating: color = gradient_average_color(self.colors, positions) return 1, 'solid', color, [], [] else: # 100 is an Arbitrary non-zero number of device units. offset = 100 / device_per_user_units if first != last: factor = (offset + last - first) / (last - first) positions = [pos / factor for pos in positions] last += offset start_x = (width - dx * distance) / 2 start_y = (height - dy * distance) / 2 points = (start_x + dx * first, start_y + dy * first, start_x + dx * last, start_y + dy * last) return 1, 'linear', points, positions, self.colors class RadialGradient(Gradient): def __init__(self, color_stops, shape, size, center, repeating): Gradient.__init__(self, color_stops, repeating) # Center of the ending shape. (origin_x, pos_x, origin_y, pos_y) self.center = center #: Type of ending shape: 'circle' or 'ellipse' self.shape = shape # size_type: 'keyword' # size: 'closest-corner', 'farthest-corner', # 'closest-side', or 'farthest-side' # size_type: 'explicit' # size: (radius_x, radius_y) self.size_type, self.size = size def layout(self, width, height, user_to_device_distance): if len(self.colors) == 1: return 1, 'solid', self.colors[0], [], [] origin_x, center_x, origin_y, center_y = self.center center_x = percentage(center_x, width) center_y = percentage(center_y, height) if origin_x == 'right': center_x = width - center_x if origin_y == 'bottom': center_y = height - center_y size_x, size_y = self._resolve_size(width, height, center_x, center_y) # http://dev.w3.org/csswg/css-images-3/#degenerate-radials if size_x == size_y == 0: size_x = size_y = 1e-7 elif size_x == 0: size_x = 1e-7 size_y = 1e7 elif size_y == 0: size_x = 1e7 size_y = 1e-7 scale_y = size_y / size_x colors = self.colors positions = process_color_stops(size_x, self.stop_positions) gradient_line_size = positions[-1] - positions[0] if self.repeating and any( gradient_line_size * unit < len(positions) for unit in (math.hypot(*user_to_device_distance(1, 0)), math.hypot(*user_to_device_distance(0, scale_y)))): color = gradient_average_color(colors, positions) return 1, 'solid', color, [], [] if positions[0] < 0: # Cairo does not like negative radiuses, # shift into the positive realm. if self.repeating: offset = gradient_line_size * math.ceil( -positions[0] / gradient_line_size) positions = [p + offset for p in positions] else: for i, position in enumerate(positions): if position > 0: # `i` is the first positive stop. # Interpolate with the previous to get the color at 0. assert i > 0 color = colors[i] neg_color = colors[i - 1] neg_position = positions[i - 1] assert neg_position < 0 intermediate_color = gradient_average_color( [neg_color, neg_color, color, color], [neg_position, 0, 0, position]) colors = [intermediate_color] + colors[i:] positions = [0] + positions[i:] break else: # All stops are negatives, # everything is "padded" with the last color. return 1, 'solid', self.colors[-1], [], [] first, last, positions = normalize_stop_postions(positions) if last == first: last += 100 # Arbitrary non-zero circles = (center_x, center_y / scale_y, first, center_x, center_y / scale_y, last) return scale_y, 'radial', circles, positions, colors def _resolve_size(self, width, height, center_x, center_y): if self.size_type == 'explicit': size_x, size_y = self.size size_x = percentage(size_x, width) size_y = percentage(size_y, height) return size_x, size_y left = abs(center_x) right = abs(width - center_x) top = abs(center_y) bottom = abs(height - center_y) pick = min if self.size.startswith('closest') else max if self.size.endswith('side'): if self.shape == 'circle': size_xy = pick(left, right, top, bottom) return size_xy, size_xy # else: ellipse return pick(left, right), pick(top, bottom) # else: corner if self.shape == 'circle': size_xy = pick(math.hypot(left, top), math.hypot(left, bottom), math.hypot(right, top), math.hypot(right, bottom)) return size_xy, size_xy # else: ellipse corner_x, corner_y = pick( (left, top), (left, bottom), (right, top), (right, bottom), key=lambda a: math.hypot(*a)) return corner_x * math.sqrt(2), corner_y * math.sqrt(2)