iOS: introdução ao UIBezierPath e implementação de gráficos estáticos

Mobile 2023-08-27 03:14:31 views: null

Introdução ao UIBezierPath

introdução básica:

UIBezierPath pode ser usado para criar caminhos vetoriais e gráficos, e vários gráficos podem ser definidos usando esta classe. Usamos uma combinação de linhas retas e arcos para criar formas complexas. Onde cada segmento reto ou curvo termina é onde o próximo começa. Cada coleção de segmentos retos ou curvos conectados é chamada de subcaminho. O caminho completo de um objeto UIBezierPath inclui um ou mais subcaminhos.

UIBezierPath possui dois métodos de implementação:

1. Use CAShapeLayer e UIBezierPath para desenhar alguns gráficos desejados. O código de exemplo é o seguinte:

UIBezierPath * path = [[UIBezierPath alloc]init];
[path moveToPoint:CGPointMake(100, 100)];
[path addLineToPoint:CGPointMake(200, 100)];
CAShapeLayer * testLayer = [CAShapeLayer layer];
testLayer.path = path.CGPath;
testLayer.lineWidth = 10;
testLayer.fillColor = [UIColor redColor].CGColor;
testLayer.strokeColor = [UIColor blackColor].CGColor;
testLayer.lineCap = kCALineCapRound;
[self.view.layer addSublayer:testLayer];

2. Reescreva o método drawRect na subclasse de UIView. Antes de executar o método drawRect da visualização, o sistema primeiro cria um contexto gráfico para a camada da visualização e, em seguida, define alguns parâmetros padrão para o estado do desenho. Nem todos precisam da cooperação do CAShapeLayer. O código de exemplo é o seguinte:

- (void)drawRect:(CGRect)rect {
UIBezierPath *path = [UIBezierPath bezierPath];
[path moveToPoint:CGPointMake(100 , 10)];
[path addLineToPoint:CGPointMake(200, 10)];
path.lineWidth = 15;
path.lineCapStyle = kCGLineCapSquare;
[[UIColor yellowColor] setStroke];
[path stroke];
}

O diagrama de efeitos dos dois trechos de código acima é o seguinte

 

As linhas nas extremidades circulares pretas da figura são desenhadas com CAShapeLayer e UIBezierPath. A linha no final do quadrado amarelo é desenhada substituindo o método drawRect.

Vamos apresentar brevemente as propriedades de UIBezierPath

1. CGPath: Converta a classe UIBezierPath em CGPath.

2.empty: Verifique se o caminho atual desenhou uma linha reta ou uma curva. Mesmo que você chame apenas o método moveToPoint, o caminho atual não é considerado vazio.

3.limites: Este atributo descreve uma área retangular mínima que pode conter completamente todos os pontos do caminho.Esta área contém os pontos de controle da curva de Bézier quadrática e da curva de Bézier cúbica.

4. currentPoint: A posição do caminho atual, que pode ser entendida como o ponto final do caminho.

5.lineWidth: largura do caminho

6.lineCapStyle: estilo do terminal do caminho.
kCGLineCapButt: Sem ponto final
kCGLineCapRound: Ponto final redondo
kCGLineCapSquare: Ponto final quadrado (o estilo é o mesmo que kCGLineCapButt, mas um pouco mais longo que kCGLineCapButt)

7.lineJoinStyle: estilo de canto
kCGLineJoinMiter: canto agudo
kCGLineJoinRound: canto arredondado
kCGLineJoinBevel: canto chanfrado

8.miterLimit: O comprimento máximo da esquadria (válido apenas quando kCGLineJoinMiter é usado), quanto menor o ângulo do canto, maior será o comprimento da esquadria. Para evitar que o comprimento da esquadria seja muito longo, use a propriedade lineLimit limit, se o comprimento da esquadria exceder miterLimit, os cantos serão exibidos como tipo KCALineJoinBevel.

9.planicidade: A precisão de renderização do caminho curvo, o padrão é 0,6. Quanto menor o valor, maior será a precisão e maior será a precisão da renderização, o que produzirá uma curva relativamente mais suave, mas levará mais tempo de cálculo.

10.usesEvenOddFillRule: Se definido como SIM, o caminho será preenchido com a regra par-ímpar, se definido como NÃO, o caminho será preenchido com a regra diferente de zero e o padrão é NÃO.
Para uma explicação específica deste atributo, consulte o seguinte link: https://developer.apple.com/reference/uikit/uibezierpath/1624360-usesevenoddfillrule?language=objc

11. UIRectCorner: Especifique qual canto do retângulo fica arredondado

UIRectCornerTopLeft: canto superior esquerdo
UIRectCornerTopRight: canto superior direito
UIRectCornerBottomLeft: canto inferior esquerdo
UIRectCornerBottomRight: canto inferior direito
UIRectCornerAllCorners: todos os quatro cantos

Introdução à API relacionada ao UIBezierPath

 

    • (instancetype)bezierPath:
      Crie um objeto UIBezierPath
    • (instancetype)bezierPathWithRect:(CGRect)rect:
      Este método criará um caminho fechado, o ponto inicial é a origem do parâmetro rect e adicionará linhas retas no sentido horário e, finalmente, formará um retângulo
    • (instancetype)bezierPathWithOvalInRect:(CGRect)rect:
      Parâmetros:
      rect->rectangular Frame
      desenha uma curva inscrita de acordo com o parâmetro retângulo reto de entrada. Quando o retângulo recebido é um quadrado, a imagem desenhada é um círculo inscrito; quando o retângulo recebido é um retângulo, a imagem desenhada é uma elipse inscrita
    • (instancetype)bezierPathWithRoundedRect:(CGRect)rect cornerRadius:(CGFloat)cornerRadius
      Parâmetros:
      rect->rectangular Frame
      cornerRadius->fillet size　　　
      Desenha uma curva retangular arredondada de acordo com um Rect Quando o Rect é um quadrado e o Raio é igual à metade do comprimento lateral desenhando um círculo
    • (instancetype)bezierPathWithRoundedRect:(CGRect)rect byRoundingCorners:(UIRectCorner)corners cornerRadii:(CGSize)cornerRadii
      parâmetros:
      rect->rectangular Frame　　　　　
      corners->canto arredondado especificadoRadii-　　　　　
      >o tamanho do canto arredondado
      Este método funciona da mesma forma que acima, diferente O local é que vocêpoderáespecificar um determinado canto ou vários cantos como cantos arredondados
    • (instancetype)bezierPathWithArcCenter:(CGPoint)raio central:(CGFloat)radius startAngle:(CGFloat)startAngle endAngle:(CGFloat)endAngle sentido horário:(BOOL)parâmetros no sentido horário: center->dot radius- > radius startAngle-　　
      >
      posição　　　　　
      inicial　　　　　
      endAngle-　　　　　 > sentido horário-> seja no sentido horário
      até o final　　　　　, especifique o ponto central e o raio para desenhar um arco ou círculo


    • (instancetype)bezierPathWithCGPath:(CGPathRef) Parâmetros CGPath　　 :
      CGPath->caminho existente
      Cria e retorna um novo objeto UIBezierPath baseado em CGPath
    • (tipo de instância)init
    • (tipo de instância anulável)initWithCoder:(NSCoder *)aDecoder
    • (CGPathRef)CGPath
      convertido em CGPath:
    • (void)moveToPoint:(CGPoint)point　　
      parâmetro:
      point->target position
      Define o ponto inicial de UIBezierPath
    • (void)addLineToPoint:(CGPoint)point　　
      parâmetro:
      point->target position
      Desenhe uma linha:
    • (void)addCurveToPoint:(CGPoint)endPoint controlPoint1:(CGPoint)controlPoint1 controlPoint2:(CGPoint)controlPoint2　　
      parâmetros:
      endPoint->ponto final　　　　　
      controlPoint1->ponto de controle 1　　　　　
      controlPoint2->ponto de controle 2
      Criar curva de Bézier cúbica: desenhar com três pontos A curva, geralmente usada em conjunto com moveToPoint:. Na verdade, o ponto final é moveToPoint: configuração, o ponto final é endPoint; a coordenada do ponto de controle 1 é controlPoint1, este parâmetro pode ser ajustado. As coordenadas do ponto de controle 2 são controlPoint2
    • (void)addQuadCurveToPoint:(CGPoint)endPoint controlPoint:(CGPoint)controlPoint　　
      Parâmetros:
      endPoint->ponto final　　　　
      controlPoint->ponto de controle
      Criar curva de Bézier quadrática: realizada chamando este método. Geralmente usado em conjunto com moveToPoint:. ponto terminal endPoint, ponto de controle controlPoint, para a curva quadrática de Bézier, há apenas um ponto de controle
    • (void)addArcWithCenter:(CGPoint)center radius:(CGFloat)radius startAngle:(CGFloat)startAngle endAngle:(CGFloat)endAngle clockwise:(BOOL)parâmetros no sentido horário: referem-se a criar um arco para adicionar um arco, bezierPathWithArcCenter é para inicializar　　
      um
      arc , addArcWithCenter é adicionar um arco, o ponto comum é que os parâmetros são os mesmos
    • (void)closePath;
      Fecha o caminho, ou seja, conecta uma linha entre o ponto final e o ponto inicial:
    • (void)removeAllPoints;
      Caminho vazio:

    • (void)appendPath:(UIBezierPath *) parâmetro bezierPath　　 :
      bezierPath->caminho anexado
      Caminho anexado:
    • (UIBezierPath *)bezierPathByReversingPath
      inverte o caminho, ou seja, o ponto inicial se torna o ponto final e o ponto final se torna o ponto inicial:
    • (void)applyTransform:(CGAffineTransform)transform; 　　
      Parâmetros:
      transform->transformação afim
      O caminho executa a transformação afim, usando a matriz de transformação afim especificada para transformar todos os pontos do caminho
    • (void)setLineDash:(nullable const CGFloat *)pattern count:(NSInteger)count phase:(CGFloat)phase　　
      parâmetro:
      padrão->　　　　
      contagem de dados lineares tipo C->número de dados na　　　　　
      fase padrão->posição inicial
      desenhe uma linha pontilhada
    • (vazio)preencher
      cor de preenchimento
    • (void)stroke;
      Desenho, a criação do caminho precisa ser desenhada para ser exibida
    • [[UIColor blackColor] setStroke];
      Para definir a cor do traço, você precisa chamar o método do traço após definir:
    • [[UIColor redColor] setFill];
      Defina a cor de preenchimento, você precisa chamar o método de preenchimento após definir
    • (void)fillWithBlendMode:(CGBlendMode)blendMode alpha:(CGFloat)alpha　　
      parâmetros:
      blendMode->blending mode　　　　
      alpha->transparency
      Use o modo de mesclagem especificado e o valor de transparência para descrever a área cercada pelo caminho de recebimento (esses métodos não afetam o modo de mesclagem ou alfa do contexto gráfico atual.)
    • (void)strokeWithBlendMode:(CGBlendMode)blendMode alpha:(CGFloat)alpha;　　
      Parâmetros:
      blendMode->blendmode　　　　
      alpha->transparency
      Use o blendmode especificado e o valor de transparência ao longo do caminho do sink. Desenhe uma linha
    • (void)addClip;
      Modifique a área de desenho do contexto gráfico atual para ficar visível e as operações de desenho subsequentes farão com que o conteúdo de renderização ocorra apenas na área preenchida do caminho especificado

exemplo específico

As renderizações e códigos dos gráficos lineares já foram mencionados no início, vejamos alguns exemplos de outros gráficos.

Exemplo 1:

Implementações de arcos, arcos e setores.
Resultados conforme mostrado abaixo:

 

código mostrado abaixo:

-(void)drawArc{
  CGFloat radius = 50.0;
  CGFloat centerx = self.view.frame.size.width/2-25;
  //code 1
  UIBezierPath *path = [UIBezierPath bezierPath];
  [path addArcWithCenter:CGPointMake(centerx, 50+64) radius:radius startAngle:0.0 endAngle:M_PI_2 clockwise:YES];
  [path stroke];
 CAShapeLayer * testLayer = [CAShapeLayer layer];
  testLayer.path = path.CGPath;
  testLayer.lineWidth = 5;
  testLayer.fillColor = [UIColor clearColor].CGColor;
  testLayer.strokeColor = [UIColor blackColor].CGColor;
  testLayer.lineCap = kCALineCapRound;
  [self.view.layer addSublayer:testLayer];
  //code 2
  UIBezierPath *path1 = [UIBezierPath bezierPath];
  [path1 moveToPoint:CGPointMake(centerx, 50+64+70)];
  [path1 addArcWithCenter:CGPointMake(centerx, 50+64+70) radius:radius startAngle:0 endAngle:M_PI_2 clockwise:YES];
  CAShapeLayer * testLayer1 = [CAShapeLayer layer];
  [testLayer1 setPath:path1.CGPath];
  [testLayer1 setFillColor:[UIColor yellowColor].CGColor];
  [testLayer1 setStrokeColor:[UIColor purpleColor].CGColor];
  [self.view.layer addSublayer:testLayer1];
  //code 3
  UIBezierPath *path2 = [UIBezierPath bezierPath];
  [path2 addArcWithCenter:CGPointMake(centerx, 50+64+140) radius:radius startAngle:0 endAngle:M_PI_2 clockwise:YES];
  [path2 closePath];
  CAShapeLayer * testLayer2 = [CAShapeLayer layer];
  [testLayer2 setPath:path2.CGPath];
  [testLayer2 setFillColor:[UIColor whiteColor].CGColor];
  [testLayer2 setStrokeColor:[UIColor blueColor].CGColor];
  [self.view.layer addSublayer:testLayer2];
}

Código 1, código 2 e código3 correspondem ao arco, ventilador e arco acima, respectivamente.

Exemplo 2:

Realização de gráficos circulares e de pizza.
Por favor, veja a figura abaixo para o efeito específico:

O código específico é o seguinte:
 

-(void)drawCircle
{
CGFloat radius = 50.0;
CGFloat centerx = self.view.frame.size.width/2-25;

//code 1
UIBezierPath *path = [UIBezierPath bezierPath];
[path addArcWithCenter:CGPointMake(centerx, 50+64+5) radius:radius startAngle:0.0 endAngle:2*M_PI clockwise:YES];
[path stroke];
CAShapeLayer * testLayer = [CAShapeLayer layer];
testLayer.path = path.CGPath;
testLayer.lineWidth = 5;
testLayer.fillColor = [UIColor clearColor].CGColor;
testLayer.strokeColor = [UIColor blackColor].CGColor;
testLayer.lineCap = kCALineCapRound;
[self.view.layer addSublayer:testLayer];

//code 2
UIBezierPath *path1 = [UIBezierPath bezierPath];
[path1 addArcWithCenter:CGPointMake(centerx, 50+64+5+110) radius:radius startAngle:0.0 endAngle:2*M_PI clockwise:YES];
[path1 stroke];
CAShapeLayer * testLayer1 = [CAShapeLayer layer];
testLayer1.path = path1.CGPath;
testLayer1.lineWidth = 2;
testLayer1.fillColor = [UIColor redColor].CGColor;
testLayer1.strokeColor = [UIColor yellowColor].CGColor;
testLayer1.lineCap = kCALineCapRound;
[self.view.layer addSublayer:testLayer1];

//code 3
UIBezierPath*  path2 = [[UIBezierPath alloc] init];
[path2 moveToPoint:CGPointMake(centerx, 50+64+5+220)];
[path2 addArcWithCenter:CGPointMake(centerx, 50+64+5+220) radius:radius startAngle:0 endAngle:M_PI_2 clockwise:YES];
[path2 addLineToPoint:CGPointMake(centerx, 50+64+5+220)];
[path2 closePath];
CAShapeLayer * testLayer2 = [CAShapeLayer layer];
testLayer2.path = path2.CGPath;
testLayer2.lineWidth = 2;
testLayer2.fillColor = [UIColor redColor].CGColor;
testLayer2.strokeColor = [UIColor whiteColor].CGColor;
testLayer2.lineCap = kCALineCapRound;
[self.view.layer addSublayer:testLayer2];

UIBezierPath*  path3 = [[UIBezierPath alloc] init];
[path3 moveToPoint:CGPointMake(centerx, 50+64+5+220)];
[path3 addArcWithCenter:CGPointMake(centerx, 50+64+5+220) radius:radius startAngle:M_PI_2 endAngle:M_PI clockwise:YES];
[path3 addLineToPoint:CGPointMake(centerx, 50+64+5+220)];
[path3 closePath];
CAShapeLayer * testLayer3 = [CAShapeLayer layer];
testLayer3.path = path3.CGPath;
testLayer3.lineWidth = 2;
testLayer3.fillColor = [UIColor yellowColor].CGColor;
testLayer3.strokeColor = [UIColor whiteColor].CGColor;
testLayer3.lineCap = kCALineCapRound;
[self.view.layer addSublayer:testLayer3];

UIBezierPath*  path4 = [[UIBezierPath alloc] init];
[path4 moveToPoint:CGPointMake(centerx, 50+64+5+220)];
[path4 addArcWithCenter:CGPointMake(centerx, 50+64+5+220) radius:radius startAngle:M_PI endAngle:2*M_PI clockwise:YES];
[path4 addLineToPoint:CGPointMake(centerx, 50+64+5+220)];
[path4 closePath];
CAShapeLayer * testLayer4 = [CAShapeLayer layer];
testLayer4.path = path4.CGPath;
testLayer4.lineWidth = 2;
testLayer4.fillColor = [UIColor blueColor].CGColor;
testLayer4.strokeColor = [UIColor whiteColor].CGColor;
testLayer4.lineCap = kCALineCapRound;
[self.view.layer addSublayer:testLayer4];
}

O código 1, o código 2 e o código3 correspondem respectivamente ao círculo vazio, ao círculo sólido e ao diagrama do setor na figura acima.

Exemplo 3:

Implementação de uma elipse.
Por favor, veja a figura abaixo para o efeito específico:

código mostrado abaixo:

-(void)drawEllipse
{
UIBezierPath *path = [UIBezierPath bezierPathWithOvalInRect:(CGRect){80,50+64,150,100}];
CAShapeLayer * testLayer = [CAShapeLayer layer];
testLayer.path = path.CGPath;
testLayer.lineWidth = 2;
testLayer.fillColor = [UIColor redColor].CGColor;
testLayer.strokeColor = [UIColor blackColor].CGColor;
[self.view.layer addSublayer:testLayer];
}

Exemplo 4:

Realização de formas irregulares.
Aqui implementei apenas um pentágono irregular e dois retângulos com cantos arredondados. Por favor, veja a imagem para o efeito específico:

 

código:

-(void)otherGraph
{
//code 1
UIBezierPath * path = [UIBezierPath bezierPath];
[path moveToPoint:CGPointMake(100, 80)];
[path addLineToPoint:CGPointMake(200, 120)];
[path addLineToPoint:CGPointMake(160, 140)];
[path addLineToPoint:CGPointMake(40.0, 140)];
[path addLineToPoint:CGPointMake(10.0, 120)];
[path closePath];
CAShapeLayer * testLayer = [CAShapeLayer layer];
testLayer.path = path.CGPath;
testLayer.lineWidth = 2;
testLayer.fillColor = [UIColor redColor].CGColor;
testLayer.strokeColor = [UIColor blackColor].CGColor;
[self.view.layer addSublayer:testLayer];

//code 2
UIBezierPath *path1 = [UIBezierPath bezierPathWithRoundedRect:CGRectMake(20, 200, 150, 100) byRoundingCorners:UIRectCornerTopLeft|UIRectCornerBottomRight cornerRadii:CGSizeMake(10, 10)];
CAShapeLayer * testLayer1 = [CAShapeLayer layer];
testLayer1.path = path1.CGPath;
testLayer1.lineWidth = 2;
testLayer1.fillColor = [UIColor clearColor].CGColor;
testLayer1.strokeColor = [UIColor blackColor].CGColor;
testLayer1.lineCap = kCALineCapRound;
[self.view.layer addSublayer:testLayer1];

}

O código 1 corresponde a um pentágono irregular e o código 2 corresponde a um retângulo com cantos arredondados.

Exemplo 5:

Implementação de cores gradientes. Por favor, veja a imagem para o efeito:

código mostrado abaixo:

-(void)drawColor
{
//code 1
UIBezierPath * path = [UIBezierPath bezierPathWithArcCenter:CGPointMake(150, 150) radius:50 startAngle:0.0 endAngle:M_PI_2 clockwise:NO];
CAShapeLayer * testLayer = [CAShapeLayer layer];
testLayer.path = path.CGPath;
testLayer.fillColor = [UIColor clearColor].CGColor;
testLayer.strokeColor = [UIColor blackColor].CGColor;
testLayer.lineWidth = 15;

CAGradientLayer *gradientLayer = [CAGradientLayer layer];
gradientLayer.frame = self.view.frame;
gradientLayer.colors = @[(__bridge id)[UIColor greenColor].CGColor,(__bridge id)[UIColor blueColor].CGColor ];
gradientLayer.startPoint = CGPointMake(0,0.5);
gradientLayer.endPoint = CGPointMake(1,0.5);

[self.view.layer addSublayer:gradientLayer];
gradientLayer.mask = testLayer;

//code 2
UIBezierPath * path1 = [UIBezierPath bezierPath];
[path1 moveToPoint:CGPointMake(100, 280)];
[path1 addLineToPoint:CGPointMake(200, 300)];
[path1 addLineToPoint:CGPointMake(250, 350)];
[path1 addLineToPoint:CGPointMake(150, 400)];
[path1 addLineToPoint:CGPointMake(50, 300)];
[path1 closePath];

CAShapeLayer * testLayer1 = [CAShapeLayer layer];
testLayer1.path = path1.CGPath;
testLayer1.lineWidth = 2;
testLayer1.fillColor = [UIColor redColor].CGColor;
testLayer1.strokeColor = [UIColor blackColor].CGColor;

CAGradientLayer *gradientLayer1 = [CAGradientLayer layer];
gradientLayer1.frame = self.view.frame;
gradientLayer1.colors = @[(__bridge id)[UIColor yellowColor].CGColor, (__bridge id)[UIColor purpleColor].CGColor ];
gradientLayer1.startPoint = CGPointMake(0,0.5);
gradientLayer1.endPoint = CGPointMake(1,0.5);

[self.view.layer addSublayer:gradientLayer1];
gradientLayer1.mask = testLayer1;
}

O código 1 corresponde à realização do arco gradiente e o código 2 corresponde à realização do polígono gradiente. A implementação de cores gradientes depende de CAGradientLayer. Alunos que desejam saber mais, pesquisem você mesmo.

Exemplo 6:

Realização de fotos irregulares.

 

código mostrado abaixo:

-(void)drawImage
{
UIImage * image = [UIImage imageNamed:@"gggggg"];
UIBezierPath *path = [[UIBezierPath alloc] init];
path.lineCapStyle = kCGLineCapRound;
path.lineJoinStyle = kCGLineJoinRound;
[path moveToPoint:CGPointMake(self.view.frame.size.width/2, 100)];
[path addArcWithCenter:CGPointMake(self.view.frame.size.width/2, 200) radius:150 startAngle:0 endAngle:M_PI clockwise:YES];
[path closePath];

CAShapeLayer * testLayer = [[CAShapeLayer alloc] init];
testLayer.frame = self.view.bounds;
testLayer.fillColor = [UIColor blackColor].CGColor;
testLayer.strokeColor = [UIColor redColor].CGColor;
testLayer.contentsScale = [UIScreen mainScreen].scale;
testLayer.path = path.CGPath;

CALayer * contentLayer = [CALayer layer];
contentLayer.frame = self.view.bounds;
contentLayer.contentsGravity = kCAGravityResizeAspectFill;
contentLayer.mask = testLayer;
contentLayer.contents = (__bridge id _Nullable)(image.CGImage);
[self.view.layer addSublayer:contentLayer];
}

Exemplo 7:

Implementação de curvas de Bézier quadráticas e cúbicas:

 

código mostrado abaixo:

-(void)drawBezierCurve
{
//code 1
UIBezierPath* path = [UIBezierPath bezierPath];
[path moveToPoint:CGPointMake(20, 150)];
[path addQuadCurveToPoint:CGPointMake(150, 160) controlPoint:CGPointMake(270, 100)];
CAShapeLayer * testLayer = [CAShapeLayer layer];
testLayer.path = path.CGPath;
testLayer.lineWidth = 2;
testLayer.fillColor = [UIColor redColor].CGColor;
testLayer.strokeColor = [UIColor blackColor].CGColor;
[self.view.layer addSublayer:testLayer];

//code 2
UIBezierPath* path1 = [UIBezierPath bezierPath];
[path1 moveToPoint:CGPointMake(20, 260)];
[path1 addCurveToPoint:CGPointMake(290, 280) controlPoint1:CGPointMake(50, 20) controlPoint2:CGPointMake(120, 380)];
[path1 stroke];
CAShapeLayer * testLayer1 = [CAShapeLayer layer];
testLayer1.path = path1.CGPath;
testLayer1.lineWidth = 2;
testLayer1.fillColor = [UIColor redColor].CGColor;
testLayer1.strokeColor = [UIColor blackColor].CGColor;
testLayer1.lineCap = kCALineCapRound;
[self.view.layer addSublayer:testLayer1];
}

O código 1 corresponde à realização da curva quadrática de Bézier e o código 2 corresponde à realização da curva cúbica de Bézier.

No GitHub, o endereço é o seguinte:

https://github.com/BigDad3/BezierPath

 

Reimpressão:
https://www.jianshu.com/p/81d83fd4a059

 

 

Acho que você gosta

Origin blog.csdn.net/KLong27/article/details/106530696
Recomendado
Clasificación
Diario
Más
2024-06-12(0)
2024-06-11(0)
2024-06-10(0)
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)
2024-06-04(0)
2024-06-03(0)

Code World

© 2018 codetd.com