Busca

Aplicando IA para edição de imagens via API da OpenAI. Aprenda a criar uma aplicação em Blazor utilizando o GPT Image Edit da OpenAI para editar imagens. Neste tutorial, vamos explorar como integrar o Blazor e .NET com a API de edição de imagens da OpenAI. Você aprenderá a criar uma aplicação que permite o upload de imagens, a modificação delas por meio de prompts e a exibição dos resultados na tela. Exploraremos detalhes como a instalação dos pacotes necessários, configuração da API e as nuances do .NET Blazor. ### Índice de Capítulos 00:00:00 Explorando o portal platform.openai.com 00:03:40 Explicando campos de API do Endpoint Images/Edits para os modelos gpt-image-1 e dall-e 00:09:07 Criando uma nova aplicação Blazor no dotnet (dotnet new e list) 00:13:37 Compilando uma aplicação Blazor (dotnet build) 00:14:01 Instalando os pacotes OpenAI e DotNetEnv (nuget - dotnet add package) 00:15:19 Explicando o uso do pacote OpenAI 00:18:18 Explicando o uso do pacote DotNetEnv 00:19:09 Executando a aplicação Blazor com dotnet watch (e Hot Reload) 00:20:05 Modificando UI da página Home no Blazor (usando Bootstrap) 00:22:29 Implementando upload de imagem usando InputFile e o evento OnChange (RequestImageFile) 00:32:11 Convertendo a imagem do upload em base64 para exibi-la na página (MemoryStream) 00:36:55 Definindo e explicando rapidamente o RenderMode (InteractiveServer) 00:40:17 Enviando a imagem para a API da OpenAI usando o pacote ImageClient e model gpt-image-1 00:42:09 Criando a ligação (binding) entre as variáveis e os controles HTML da página 00:45:00 Criando API Key na plataforma OpenAI e gravando em variáveis de ambiente usando o DotNetEnv 00:45:34 Explicando opções no Dashboard da API na plataforma da OpenAI (Usage, etc.) 00:56:42 Implementando tratamento de erros e ampulheta de processamento (feedback visual) 01:06:30 Explicando a verificação de perfil para ser possível usar o Endpoint Images/Edits

Comunicação por TCP Sockets em C#: Blazor, Console e WinForms integrados em um Tutorial Completo! Este vídeo une e organiza três conteúdos completos sobre comunicação via TCP Sockets em C# e .NET, mostrando desde os conceitos iniciais até a implementação prática com Console Server, Blazor Client e WinForms Client. Você aprenderá passo a passo como: - Conceituar a comunicação por Sockets e entender diferenças para HTTP - Criar um Server TCP em .NET Console com TcpListener - Criar Clients TCP em Blazor Server e WinForms - Trabalhar com StreamReader e StreamWriter para envio/recebimento de mensagens - Gerenciar múltiplas conexões simultâneas (broadcast para todos os sockets) - Usar Task, Invoke, InvokeAsync e StateHasChanged para atualizar a UI - Tratar erros e desconexões de clientes - Integrar tudo em uma aplicação prática de comunicação cliente/servidor # Índice de Capítulos - 00:00:00 Conceitualizando a Comunicação por Sockets - 00:05:07 Criando a aplicação TCP Server .Net Console (dotnet new) - 00:10:31 Criando o Listener de TCP com o TcpListener - 00:13:15 Criando o loop para aguardar conexões TCP (AcceptTcoClient) - 00:13:48 Criando a tarefa (Task) que receberá e responderá as mensagens TCP - 00:15:16 Definindo os fluxos, geral (Stream), de envio (StreamWriter) e recebimento (StreamReader) - 00:15:41 Explicando a diferença entre conexão por Socket e comum HTTP - 00:19:57 Recebendo a mensagem TCP enviada pelo Client (Stream.ReadLine) - 00:21:53 Respondendo a mensagem TCP enviada pelo Client (Stream.WriteLine) - 00:27:29 Compilando a aplicação TCP Server .Net Console (dotnet build) - 00:27:58 Criando e executando a aplicação TCP Client em Blazor (Server) com .Net (dotnet new blazor) - 00:30:30 Criando a Interface (UI) em Blazor para o TCP Client (HTML, CSS e Bootstrap) - 00:35:00 Definindo os fluxos, geral (NetworkStream), envio (StreamWriter) e recebimento (StreamReader) - 00:39:19 Definindo os Bindings fazendo a ligação entre Interface (UI) e Código - 00:41:54 Inicializando o TCP Client (TcpClient) - 00:44:03 Criando a tarefa (Task) que define os fluxos (stream) de recebimento e resposta de mensagens TCP - 00:46:47 Atualizando, de uma Task externa, a Interface (UI) em Blazor (InvokeAsync, StateHasChange) - 00:47:36 Definindo método para envio de mensagens TCP (Stream.WriteLine) - 00:51:32 Definindo e detalhando o RenderMode InteractiveServer - 00:55:16 Tratando erros em uma aplicação .Net Blazor - 00:59:26 Compilando, executando e testando 2 aplicações .Net Blazor e Console (Client e TCP Server) - 01:02:25 Criando uma class auxiliar e um Dictionary de Streams de TcpClient - 01:07:46 Pegando o EndPoint do Client Socket conectado e incluindo no Dictionary - 01:11:24 Loop para responder a todos os Clients Socket TCP conectados (Broadcast) - 01:12:09 Verificando se o Client Socket TCP está conectado - 01:12:58 Desconectando Streams Client Socket TCP e o removendo do Dictionary - 01:14:51 Respondendo a um Client Socket TCP no seu StreamWriter - 01:16:42 Trocando um Dictionary por um ConcurrentDictionary de Clients Socket TCP - 01:19:08 Explicação completa de um Server Socket TCP em .net Console (TcpListener) - 01:28:26 Explicação completa de um Client Socket TCP em .net Blazor (TcpClient) - 01:31:35 Compilando e executando 2 aplicação Client e Server TCP em .net (Blazor e Console) - 01:43:56 Criando um Client Socket usando WinForms no Visual Studio 2022 - 01:46:03 Ajustando Componentes de interface (UI) no Winforms - 01:48:34 Conectando ao server TcpClient e definindo os fluxos (StreamReader e StreamWriter) - 01:52:23 Tratando o recebimento mensagens dos Clients usando StreamReader - 01:52:52 Usando Invoke para preencher uma ListBox na MainThread a partir de uma Task - 01:54:22 Codificando evento Click botão para enviar mensagens ao Socket Server (StreamWriter) - 01:55:54 Testando Sockets entre os Clientes Winforms e Blazor e o Server .net Console

Aprenda a consumir a API do MixCloud com .NET MAUI e Blazor, criando uma aplicação C# e integrando dados externos Neste vídeo tutorial, vamos explorar como construir uma aplicação multi-plataforma utilizando .NET MAUI Blazor com C#, consumindo dados da API do MixCloud. Você aprenderá desde conceitos básicos sobre .NET MAUI e Blazor até a criação de um cliente HTTP para consumir API’s de forma eficiente. O conteúdo abrange a instalação de workloads necessários, configuração de projetos MAUI Blazor, manipulação de formulários e componentes via Blazor, além de um guia passo a passo sobre como integrar e consumir o conteúdo através de chamadas HTTP. Detalhamos também a estruturação dos modelos C# para deserialização dos dados recebidos da API do MixCloud. Com um exemplo prático e didático, este vídeo é voltado para desenvolvedores iniciantes em .NET MAUI ou Blazor que desejam consolidar conceitos de integração de API em suas aplicações. ### Índice de Capítulos 00:00 - Introdução ao vídeo e objetivo 00:45 - Link dos recursos na descrição 01:18 - Explicação sobre .NET MAUI e Blazor 02:57 - Introdução à API do MixCloud 05:47 - Discussão sobre parâmetros da API 08:00 - Configuração do Base URL e parâmetros da API 12:41 - Criando projeto com .NET New 15:22 - Exploração de workloads no .NET 18:23 - Organização de soluções e projetos no .NET 24:30 - Compilação e teste inicial do projeto 27:36 - Configurando extensões recomendadas 30:06 - Trabalhando com páginas e layout no Blazor 32:15 - Construção de um formulário no Blazor 37:35 - Ajuste de layout e responsividade 47:14 - Uso do "Paste JSON as Code" para modelos 49:42 - Instalando componente (NewtonSoft.Json) 51:49 - Adicionando namespaces organizados 54:49 - Ligação de variáveis com elementos no Blazor 56:30 - Utilização do @bind e métodos de busca 1:02:09 - Exibição de resultados no layout 1:04:45 - Simplificação do modelo JSON 1:06:40 - Implementação do método de busca (Search) 1:08:58 - Introdução ao uso de await e chamadas assíncronas 1:14:15 - Testes iniciais com buscas no MixCloud 1:21:22 - Correção de erros e injeção de dependência com HttpClient 1:23:15 - Resolução de nullable warnings no C# 1:27:15 - Tratamento de erros para requisições na API

Aprenda a usar Blazor e a API Clipdrop para remover fundos de imagem de forma eficaz Neste tutorial, mostraremos como criar uma aplicação em Blazor utilizando C# e a API do Clipdrop (que uso o Stable Diffusion) para remover automaticamente o fundo de imagens. Ao longo do vídeo, você aprenderá a configurar seu ambiente de desenvolvimento, manusear a API do Clipdrop e implementar funcionalidades que permitem o upload e processamento de imagens diretamente na aplicação. Você também verá como manipular requisições HTTP e trabalhar com injeção de dependência no .NET. Esta aplicação oferece um ponto de partida para desenvolvedores interessados em incorporar funcionalidades de manipulação de imagem usando inteligência artificial em seus projetos. **Índice de Capítulos:** - 00:00:00 Apresentação da Clipdrop e sua API - 00:02:38 Acesso à API do Clipdrop (API Key) - 00:04:30 Criando o projeto .net Blazor - 00:06:15 Estrutura inicial do projeto .net Blazor - 00:06:30 Uso de Extensões e Perfis com VSCode com .net Blazor - 00:13:10 Layout da página usando Razor com .net Blazor - 00:16:00 Codificação da página usando C# com .net Blazor - 00:25:28 Implementando upload de imagens no .net Blazor - 00:31:40 Configurando rendermode InteractiveServer no .net Blazor - 00:34:15 Criando POST MultiPartFormData para a API do Clipdrop - 00:38:17 Usando Injeção de Dependência (DI) no .net Blazor (HttpClient) - 00:41:33 Preenchendo form MultiPartFormData por código no .net Blazor (HttpClient)

Tutorial prático: Construa um Client Blazor e implemente comunicação TCP com Sockets no .NET Desenvolvendo Sistemas: Blazor Server e TcpListener com Sockets em .NET! Neste vídeo tutorial, você aprenderá a implementar a comunicação de Sockets usando Blazor Server e .NET do zero. Exploraremos como configurar um servidor TCP, conectar múltiplos clientes e implementar uma comunicação simultânea baseada em Sockets. Este guia prático é ideal para desenvolvedores interessados em enriquecer suas aplicações web com funcionalidades de tempo real, como chats e notificações de eventos. O vídeo é uma continuação de um tutorial anterior que mostrava como fazer comunicação com WebSockets usando HTML e JavaScript, proporcionando uma comparação interessante entre essas tecnologias. ### Índice de Capítulos - 00:00:00 - Conceitualizando a Comunicação por Sockets - 00:05:07 - Criando a aplicação TCP Server .Net Console (dotnet new) - 00:10:31 - Criando o Listener de TCP com o TcpListener - 00:13:15 - Criando o loop para aguardar conexões TCP (AcceptTcoClient) - 00:13:48 - Criando a tarefa (Task) que receberá e responderá as mensagens TCP - 00:15:16 - Definindo os fluxos, geral (Stream), de envio (StreamWriter) e recebimento (StreamReader) - 00:15:41 - Explicando a diferença entre conexão por Socket e comum HTTP - 00:19:57 - Recebendo a mensagem TCP enviada pelo Client (Stream.ReadLine) - 00:21:53 - Respondendo a mensagem TCP enviada pelo Client (Stream.WriteLine) - 00:27:29 - Compilando a aplicação TCP Server .Net Console (dotnet build) - 00:27:58 - Criando e executando a aplicação TCP Client em Blazor (Server) com .Net (dotnet new blazor) - 00:30:30 - Criando a Interface (UI) em Blazor para o TCP Client (HTML, CSS e Bootstrap) - 00:35:00 - Definindo os fluxos, geral (NetworkStream), envio (StreamWriter) e recebimento (StreamReader) - 00:39:19 - Definindo os Bindings fazendo a ligação entre Interface (UI) e Código - 00:41:54 - Inicializando o TCP Client (TcpClient) - 00:44:03 - Criando a tarefa (Task) que define os fluxos (stream) de recebimento e resposta de mensagens TCP - 00:46:47 - Atualizando, de uma Task externa, a Interface (UI) em Blazor (InvokeAsync, StateHasChange) - 00:47:36 - Definindo método para envio de mensagens TCP (Stream.WriteLine) - 00:51:32 - Definindo e detalhando o RenderMode InteractiveServer - 00:55:16 - Tratando erros em uma aplicação .Net Blazor - 00:59:26 - Compilando, executando e testando 2 aplicações .Net Blazor e Console (Client e TCP Server)

Descubra como integrar facilmente o serviço de e-mail Resend com o ASP.NET usando Razor Views. O mesmo exemplo pode ser feito em Blazor com poucas adaptações. Domine o envio de emails em suas aplicações de maneira prática e eficiente. ### Índice de Capítulos: - 00:00 Explicação sobre o Resend e configuração de domínios - 03:10 Criação e configuração de API Keys no Resend - 03:37 Exploração do GitHub do Resend e de seu criador - 04:42 Configuração de envio de emails via API - 11:15 Estrutura inicial em Razor e conceitos de layout - 14:22 Criação de formulário de envio de email no Razor - 19:29 Code Behind e tratamento de métodos no Razor - 23:42 Debugging da aplicação - 25:43 Tratamento de erro e explicando o comportamento da página - 30:20 Codificação do envio de e-mail usando Resend com código no Code Behind (MailMessage) - 30:25 Informações sobre os SDKs do Resend e SMTP - 38:52 Melhorias no código e no tratamento de configuração de emails (Configutation) - 44:55 Criação de EmailService e refatorações de código (Dependecy Inject) - 53:44 Concluindo o serviço de envio de email com Resend

Aprenda a usar OAuth para autenticação com Spotify, aplicando conhecimentos a serviços como Google e Facebook. Neste vídeo, você aprenderá a integrar a autenticação OAuth com o Spotify, utilizando um exemplo prático em Blazor para criar um aplicativo que lista as playlists de um usuário. Vamos explorar o uso da API do Spotify, criar um aplicativo no painel de desenvolvedores e entender como o mesmo processo pode ser aplicado ao Google, Facebook e outros. Este guia passo a passo abrange desde a configuração inicial no site do Spotify até considerações de segurança. Ideal para desenvolvedores que desejam incorporar autenticação em suas aplicações. **Capítulos:** - 00:00:00 - Explicação sobre OAuth - 00:01:26 - Explorando a Documentação da API Spotify - 00:03:31 - Criação, Modificação e Exclusão do Aplicativo na API Spotify - 00:06:16 - Preparando o Ambiente e Criando o projeto Blazor (dotnet new blazor) - 00:08:44 - Compilando e Executando o Projeto Blazor (dotnet build e watch) - 00:10:21 - Criando Interface (UI) do Aplicativo (com Razor, Html e Bootstrap) - 00:15:18 - Criando variáveis para serem exibidas nas tags Html p - 00:16:01 - Definindo o RenderMode para InteractiveServer - 00:18:11 - Criando método para Autenticação OAuth e página de Consentimento - 00:19:33 - Definindo ClientId, Secret, Url de Redirecionamento, Scope e State - 00:27:37 - Criando o EndPoint para recebimento do Code na Url de Retorno do Spotify (OnParametersSet) - 00:32:41 - Criando Método para Requisição do Access Token, através do Code, ClientId e Secret - 00:35:56 - Criando o Fluxo Condicional no arquivo Razor - 00:36:46 - Criando Método para listar as Playlists do usuário do Spotify - 00:38:51 - Habilitando Detalhamento de Erros no Blazor (AddCircuitOptions) - 00:40:43 - "Tipando" o retorno da API do Spotify (usando o Paste Json as Code) - 00:42:06 - Criando os DTOs (nesse caso Models) mapeados com a API do Spotify (JsonPropertyName) - 00:47:28 - Criando o Binding entre o Model com dados da API do Spotify e o Html da página Razor - 00:50:38 - Criando Ampulheta (Loading) e Tratamento de erros - 00:56:04 - Protegendo as chaves ClientId e Secret nos arquivos de configuração appSettings

Aprenda a criar uma aplicação Blazor usando C# para consumir a API do Deezer, do desenvolvimento básico ao intermediário.

Neste vídeo, exploramos o básico do acesso a banco de dados no .NET usando o Entity Framework Core. Vamos aprender a criar uma aplicação simples com Blazor, configurar o Entity Framework, trabalhar com banco de dados em memória (InMemory) e persistente (SQLite), e criar e consultar registros. ### Índice de Capítulos - 00:00:00 - Listando Workloads e criando um Projeto com .NET New (dotnet new blazor) - 00:03:06 - Explorando Profiles do VSCode - 00:04:03 - Compilando e executando a aplicação (dotnet build, dotnet watch) - 00:06:08 - Explicando rapidamente rotas em páginas Razor no Blazor - 00:07:04 - Codificando a UI Interface do usuário usando Razor com HTML e Bootstrap - 00:08:00 - Introdução ao Entity Framework e ORM - 00:08:52 - Criando Models (Modelo de dados) e verificando atributos (Attributes) - 00:11:11 - Discutindo sobre string nullable e inicialização de variáveis - 00:12:30 - Instalando packages nuget para Entity Framework InMemory e SQLite - 00:13:46 - Criando o contexto para acesso a banco de dados DbContext usando o Entity Framework - 00:15:53 - Usando modo Fluent para definição de regras, nomes de tabela, tipos de dados (OnModelCreating) - 00:17:49 - Configurando o DbContext e Banco de Dados InMemory - 00:19:27 - Implementando a Lógica de Interface UI com Blazor usando Bootstrap - 00:22:53 - Incluindo código C# em uma página Razor no Blazor - 00:23:17 - Criando e instanciando uma lista de itens baseada numa entidade do Entity Framework (List T ) - 00:24:08 - Percorrendo uma lista de registros (Entity Framework) para exibição em tabela - 00:25:16 - Incluindo e salvando registros no banco de dados usando o Entity Framework - 00:25:47 - Criando ligação (Binding) e Interatividade entre variáveis e a página Razor no Blazor - 00:26:35 - Definindo RenderMode (InteractiveServer) para uma página Razor no Blazor - 00:28:56 - Injetando DbCotextFactory para acesso à dados numa página Razor no Blazor - 00:30:52 - Registrando DbCotextFactory como serviço injetável no Program.cs - 00:32:33 - Listando registros do banco de dados usando o DbContext do Entity Framework - 00:35:46 - Configurando o DbContext e Banco de Dados SQLite - 00:36:52 - Codificando a criação do banco de dados (sem migrations) usando o DbContext do Entity Framework - 00:39:24 - Consultando o banco de dados SQLite usando linha de comando e extensões do VSCode

Neste tutorial, vamos dar continuidade ao projeto de lista de tarefas usando Blazor Server, perfeito para quem está iniciando na área de desenvolvimento web com tecnologias .NET. Abordaremos conceitos como Dependency Injection, Entity Framework, Migrations, Fluent API, páginas Razor, criação de componentes, e interação entre front e back-end de forma simples e prática. Curta o vídeo e inscreva-se no canal para não perder os próximos conteúdos! 00:00:00 - Introdução 00:04:20 - Configurando o Ambiente de Desenvolvimento 00:11:39 - Criação da Aplicação Blazor Server 00:21:11 - Extensões do VSCode para programar .Dotnet 00:22:58 - Explicação do Modelo de Dados (Models) 00:34:55 - Explicando namespaces 00:38:00 - Relacionamentos entre tabelas com Entity Framework 00:45:39 - Criando um Contexto com Entity Framework 00:55:41 - Validações usando a Fluent API com EF 00:58:34 - Seed de Dados Iniciais com Entity Framework 01:01:46 - Configurando Strings de Conexão para EF 01:04:39 - Dependency Inject do Contexto Entity Framework 01:07:11 - Migrations do Entity Framework 01:14:48 - Criando um Service para CRUD usando DI do Contexto EF 01:17:44 - Consulta (Query) usando Linq e o Contexto do EF 01:38:24 - Rotas e Páginas Razor no Blazor 01:41:10 - Desenvolvendo a Interface de Usuário (Razor e Bootstrap) 01:56:57 - Criando Componentes Reutilizáveis no Blazor 01:59:18 - Propriedades, Manipulação de Eventos e Data Binding no Blazor 02:11:14 - Injeção de Dependência (Dependency Injection) em Páginas Blazor 02:17:24 - Manipulação de Eventos e Data Binding no Blazor 02:19:24 - Operações de CRUD com Service e EF na Lista de Tarefas 02:28:25 - Atribuindo RenderMode InteractiveServer ao Componente 02:29:32 - Estilos Condicionalmente na página 02:39:00 - Dados iniciais da página Razor (OnInitializedAsync) 02:43:55 - Propriedades NotMapped (não mapeadas) no Model EF 02:47:39 - Ajustando a Ordenação com o Entity Framework

Descubra como implementar o BERT para previsão de palavras em sua aplicação utilizando C# e Blazor Neste vídeo, exploramos o uso do BERT da Google, um modelo de linguagem natural poderoso, para previsão de palavras. Vamos apresentar o funcionamento do modelo bert-base-uncased e suas aplicações práticas. Você aprenderá a utilizar este modelo em um aplicativo Blazor, descobrindo como prever palavras em frases incompletas e entender a metodologia de Masked Language Modeling (MLM). O BERT é conhecido por sua capacidade de ignorar distinções entre maiúsculas e minúsculas, tornando o processo de previsão mais eficiente. Durante o tutorial, abordaremos como buscar datasets de treino, entender as estruturas de request e response, e integrar o modelo em um projeto .NET Blazor. Ao seguir este guia passo a passo, você descobrirá formas criativas de aplicar a IA de linguagem natural em suas soluções de desenvolvimento de software. ## Capítulos do Vídeo - 00:00:00 - Localizando e Explorando o modelo bert-base-uncased - 00:08:04 - Testando o BERT no Huggingface - 00:10:22 - Gerando Access Token para o BERT no Huggingface - 00:11:39 - Criando uma aplicação Blazor (dotnet new blazor) - 00:13:27 - Definindo o RenderMode InteractiveServer - 00:14:12 - Definindo configurações no AppSettings.json - 00:15:44 - Extraindo a Base Url da API e o Request Json do Huggingface - 00:18:02 - Compilando e Executando Aplicação Blazor - 00:18:26 - Tipando o request usando o DTO com JsonPropertyName - 00:21:27 - Trabalhando a interface de usuário (UI) em Razor e Bootstrap - 00:22:10 - Criando o Binding em métodos e propriedades e o HTML/Razor - 00:25:11 - Injetando o HttpClient e criando o Request para o Inference Provider do Huggingface - 00:27:08 - Usando o IConfiguration para obter configuração de API Url e Api Key - 00:31:53 - Definindo permissões para a API do Huggingface - 00:32:54 - Tipando o Response da API do bert-base-uncased no Huggingface - 00:41:24 - Implementando tratamento de erros - 00:43:33 - Comentando sobre a cotas, planos e preços do Huggingface

Compartilhamos um tutorial detalhado sobre como criar animações em SVG usando .NET Blazor e C#. Você aprenderá a aplicar técnicas de animação para desenvolver barras de progresso dinâmicas e interativas em aplicativos Web, tendo como destaque a possibilidade de usar SVG em vez do tradicional canvas, oferecendo um resultado visualmente atraente e performático. Ao longo do vídeo, aprenderemos passo a passo a configurar um novo projeto Blazor, explorar a estrutura de arquivos do projeto, e adicionar animações em SVG ao HTML gerado. ### Índice de Capítulos 00:00 - Organização de projetos e criação da aplicação Blazor (dotnet new blazor) 03:30 - Configuração do ambiente Blazor e dicas de extensões para Visual Studio Code 04:32 - Estrutura inicial do projeto Blazor (template padrão Blazor e suas páginas) 05:17 - Compilação Inicial e .NET CLI (dotnet build) 05:49 - Comando dotnet watch para atualizações dinâmicas no navegador 10:04 - Declaração e Utilização de Variáveis 11:11 - Criação de estilos personalizados (CSS) do Blazor (Separação de layout) 14:34 - Utilização do evento onClick para manipular o valor de uma variável com fluxo condicional 15:11 - Render Modes no Blazor 21:12 - Implementação da barra de progresso com Bootstrap (dinamicamente) 25:29 - Animando SVG com substituição de valores fixos pelo valor dinâmico de variáveis