def test_PathEffect_asPoints(patheffect): results = skia.PathEffect.PointData() path = skia.Path() path.addCircle(10, 10, 5) rec = skia.StrokeRec(skia.StrokeRec.kHairline_InitStyle) matrix = skia.Matrix() assert isinstance(patheffect.asPoints(results, path, rec, matrix, None), bool)
def transform(self, transform, center=(0, 0)): cx, cy = center t = Transform() t = t.translate(cx, cy) t = t.transform(transform) t = t.translate(-cx, -cy) matrix = skia.Matrix() matrix.setAffine(t) self.path.transform(matrix)
def transform(self, matrix, center=(0, 0)): m = skia.Matrix() m.setAffine(matrix) cx, cy = center if cx != 0 or cy != 0: self._canvas.translate(cx, cy) self._canvas.concat(m) self._canvas.translate(-cx, -cy) else: self._canvas.concat(m)
def __gradient_matrix(gradient, path): #===================================== if gradient.attrib.get('gradientUnits') == 'userSpaceOnUse': path_transform = Transform.Identity() else: # objectBoundingBox' bounds = path.getBounds() path_transform = Transform([[bounds.width(), 0, bounds.left()], [ 0, bounds.height(), bounds.top()], [ 0, 0, 1]]) svg_transform = SVGTransform(gradient.attrib.get('gradientTransform')) return skia.Matrix(list((path_transform@svg_transform).flatten()))
def __init__(self, paint, bounds, parent_transform, transform_attribute, clip_path, bbox=None, root_object=False): if root_object: T = parent_transform@SVGTransform(transform_attribute) self.__matrix = skia.Matrix(list(T.flatten())) else: T = parent_transform if transform_attribute is None: self.__matrix = None else: local_transform = SVGTransform(transform_attribute) self.__matrix = skia.Matrix(list(local_transform.flatten())) T = T@local_transform if bounds is not None and bbox is None: bbox = T.transform_geometry(shapely.geometry.box(*tuple(bounds))) self.__bbox = bbox self.__prep_bbox = shapely.prepared.prep(bbox) if bbox is not None else None self.__clip_path = clip_path self.__paint = paint self.__save_state = (self.__matrix is not None or self.__clip_path is not None)
def image(self, src=None, opacity=1, rect=None, pattern=True): if isinstance(src, skia.Image): image = src else: image = skia.Image.MakeFromEncoded( skia.Data.MakeFromFileName(str(src))) if not image: print("image <", src, "> not found, cannot be used") return _, _, iw, ih = image.bounds() if pattern: matrix = skia.Matrix() matrix.setScale(rect.w / iw, rect.h / ih) self.paint.setShader( image.makeShader(skia.TileMode.kRepeat, skia.TileMode.kRepeat, matrix)) if opacity != 1: tf = skia.ColorFilters.Matrix([ 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, opacity, 0 ]) cf = self.paint.getColorFilter() if cf: self.paint.setColorFilter(skia.ColorFilters.Compose(tf, cf)) else: self.paint.setColorFilter(tf) if not pattern: bx, by, bw, bh = self.path.getBounds() if rect: bx, by = rect.flip(self.rect.h).xy() #bx += rx #by += ry sx = rect.w / iw sy = rect.h / ih self.canvas.save() #self.canvas.setMatrix(matrix) self.canvas.clipPath(self.path, doAntiAlias=True) self.canvas.scale(sx, sy) self.canvas.drawImage(image, bx / sx, by / sy, self.paint) self.canvas.restore() return True
__and__ = intersection def __iand__(self, other): result = self.intersection(other) self.path = result.path return self __xor__ = xor def __ixor__(self, other): result = self.xor(other) self.path = result.path return self FLIP_MATRIX = skia.Matrix() FLIP_MATRIX.setAffine((1, 0, 0, -1, 0, 0)) def _convertConicToCubicDirty(pt1, pt2, pt3): # # NOTE: we do a crude conversion from a conic segment to a cubic bezier, # for two common cases, based on the following assumptions: # - drawbot itself does not allow conics to be drawn # - skia draws conics implicitly for oval(), arc() and arcTo() # - for oval the conic segments span 90 degrees # - for arc and arcTo the conic segments do not span more than 90 degrees # - for arc and arcTo the conic segments are circular, never elliptical # For all these cases, the conic weight will be (close to) zero. # # This no longer holds once a path has been transformed with skew or x/y
def test_Matrix_init(args): assert isinstance(skia.Matrix(*args), skia.Matrix)
def test_ImageFilter_CropRect_applyTo(croprect): assert isinstance( croprect.applyTo(skia.IRect(100, 100), skia.Matrix(), False), skia.IRect)
canvas.scale(1, 1) @pytest.mark.parametrize('args', [ (0, ), (0, 0, 0), ]) def test_Canvas_rotate(canvas, args): canvas.rotate(*args) def test_Canvas_skew(canvas): canvas.skew(0, 0) @pytest.mark.parametrize('arg', [skia.Matrix(), skia.M44()]) def test_Canvas_concat(canvas, arg): canvas.concat(arg) def test_Canvas_setMatrix(canvas): canvas.setMatrix(skia.Matrix()) def test_Canvas_resetMatrix(canvas): canvas.resetMatrix() @pytest.mark.parametrize('args', [ (skia.Rect(320, 240), skia.ClipOp.kIntersect, True), (skia.Rect(320, 240), True),
def matrix(): return skia.Matrix()
def transform(self, matrix): m = skia.Matrix() m.setAffine(matrix) self._canvas.concat(m)
def test_ImageFilters_MatrixTransform(): assert isinstance(skia.ImageFilters.MatrixTransform( skia.Matrix(), skia.FilterQuality.kLow_FilterQuality), skia.ImageFilter)
def test_Matrix_decomposeScale(matrix): scale = skia.Size(0, 0) remaining = skia.Matrix() assert isinstance(matrix.decomposeScale(scale, remaining), bool)
def test_Canvas_setMatrix(canvas): canvas.setMatrix(skia.Matrix())
def test_Shader_makeWithLocalMatrix(shader): assert isinstance(shader.makeWithLocalMatrix(skia.Matrix()), skia.Shader)
( skia.TextBlob('foo', skia.Font()), 0, 0, skia.Paint(), ), ]) def test_Canvas_drawTextBlob(canvas, args): canvas.drawTextBlob(*args) @pytest.mark.parametrize('args', [ (skia.Picture(skia.Rect(100, 100)), ), ( skia.Picture(skia.Rect(100, 100)), skia.Matrix(), ), ( skia.Picture(skia.Rect(100, 100)), skia.Matrix(), skia.Paint(), ), ( skia.Picture(skia.Rect(100, 100)), None, skia.Paint(), ), ]) def test_Canvas_drawPicture(canvas, args): canvas.drawPicture(*args)
def test_MatrixPathEffect_Make(): assert isinstance(skia.MatrixPathEffect.Make(skia.Matrix()), skia.PathEffect)
def test_Path2DPathEffect_Make(): path = skia.Path() path.addCircle(10, 10, 5) assert isinstance(skia.Path2DPathEffect.Make(skia.Matrix(), path), skia.PathEffect)
def test_ImageFilter_makeWithLocalMatrix(imagefilter): assert isinstance( imagefilter.makeWithLocalMatrix(skia.Matrix()), skia.ImageFilter)
def test_ImageFilter_MakeMatrixFilter(imagefilter): assert isinstance( skia.ImageFilter.MakeMatrixFilter( skia.Matrix(), skia.FilterQuality.kHigh_FilterQuality, imagefilter), skia.ImageFilter)
def test_Canvas_concat(canvas): canvas.concat(skia.Matrix())
def test_Matrix_postConcat(matrix): assert isinstance(matrix.postConcat(skia.Matrix()), skia.Matrix)
import pytest @pytest.fixture def shader(): return skia.GradientShader.MakeLinear( [skia.Point(0, 0), skia.Point(1, 1)], [0xFFFF00FF, 0xFFFFFF00], []) def test_Shader_isOpaque(shader): assert isinstance(shader.isOpaque(), bool) @pytest.mark.parametrize('args', [ (skia.Matrix(), [skia.TileMode.kClamp, skia.TileMode.kClamp]), tuple(), ]) def test_Shader_isAImage(shader, args): assert isinstance(shader.isAImage(*args), (bool, type(None), skia.Image)) def test_Shader_asAGradient(shader): info = skia.Shader.GradientInfo() assert isinstance(shader.asAGradient(info), skia.Shader.GradientType) def test_Shader_makeWithLocalMatrix(shader): assert isinstance(shader.makeWithLocalMatrix(skia.Matrix()), skia.Shader)
def test_Matrix_invert(matrix): assert isinstance(matrix.invert(skia.Matrix()), bool)
(skia.RRect.MakeRect(skia.Rect(100, 100)), skia.PathDirection.kCCW, 0), ]) def test_Path_addRRect(path, args): assert isinstance(path.addRRect(*args), skia.Path) def test_Path_addPoly(path): assert isinstance(path.addPoly([skia.Point(10, 10)], True), skia.Path) @pytest.mark.parametrize('args', [ (skia.Path(), 0, 0), (skia.Path(), ), ( skia.Path(), skia.Matrix(), ), ]) def test_Path_addPath(path, args): assert isinstance(path.addPath(*args), skia.Path) def test_Path_reverseAddPath(path): assert isinstance(path.reverseAddPath(skia.Path()), skia.Path) @pytest.mark.parametrize('args', [ ( 0, 0, skia.Path(),
def test_ImageFilter_CropRect_flags(croprect): assert isinstance(croprect.flags(), int) def test_ImageFilter_CropRect_rect(croprect): assert isinstance(croprect.rect(), skia.Rect) def test_ImageFilter_CropRect_applyTo(croprect): assert isinstance( croprect.applyTo(skia.IRect(100, 100), skia.Matrix(), False), skia.IRect) @pytest.mark.parametrize('args', [ (skia.IRect(100, 100), skia.Matrix(), skia.ImageFilter.kForward_MapDirection), (skia.IRect(100, 100), skia.Matrix(), skia.ImageFilter.kReverse_MapDirection, skia.IRect(100, 100)) ]) def test_ImageFilter_filterBounds(imagefilter, args): assert isinstance(imagefilter.filterBounds(*args), skia.IRect) def test_ImageFilter_isColorFilterNode(imagefilter): assert isinstance( imagefilter.isColorFilterNode(), (skia.ColorFilter, type(None))) def test_ImageFilter_countInputs(imagefilter): assert isinstance(imagefilter.countInputs(), int)