Documentação para desenvolvedores de vetorização de imagens

Vectorizer.AI oferece SDKs oficiais, um cliente de linha de comando, especificações OpenAPI e uma API completa de rastreamento de bitmap. Todas essas ferramentas de desenvolvedor usam o mesmo serviço para rastrear pixels em vetores de forma totalmente automática e com a melhor fidelidade da categoria.

Guia de início rápido da API direta

Para integrações HTTP diretas, PUBLIQUE uma imagem de bitmap e receba um resultado vetorizado:

• File
• URL

$ curl https://pt.vectorizer.ai/api/v1/vectorize \
 -u xyz123:[secret] \
 -F image=@example.jpeg \
 -o result.svg

// Requires: org.apache.httpcomponents.client5:httpclient5-fluent

Request request = Request.post("https://pt.vectorizer.ai/api/v1/vectorize")
   .addHeader("Authorization", "Basic dmt5YzY3a3FhMjd5aWRkOltzZWNyZXRd")
   .body(
      MultipartEntityBuilder.create()
         .addBinaryBody("image", new File("example.jpeg")) // TODO: Replace with your image
         // TODO: Add more upload parameters here
         .build()
      );
ClassicHttpResponse response = (ClassicHttpResponse) request.execute().returnResponse();

if (response.getCode() == 200) {
   // Write result to disk, TODO: or wherever you'd like
   try (FileOutputStream out = new FileOutputStream("result.svg")) {
      response.getEntity().writeTo(out);
   }
} else {
   System.out.println("Request Failed: Status: " + response.getCode() + ", Reason: " + response.getReasonPhrase());
}

using (var client = new HttpClient())
using (var form = new MultipartFormDataContent())
{
   client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", "INSERT_API_KEY_HERE");
   form.Add(new ByteArrayContent(File.ReadAllBytes("example.jpeg")), "image", "example.jpeg"); // TODO: Replace with your image
   // TODO: Add more upload parameters here

   var response = client.PostAsync("https://pt.vectorizer.ai/api/v1/vectorize", form).Result;

   if (response.IsSuccessStatusCode)
   {
      // Write result to disk, TODO: or wherever you'd like
      FileStream outStream = new FileStream("result.svg", FileMode.Create, FileAccess.Write, FileShare.None);
      response.Content.CopyToAsync(outStream).ContinueWith((copyTask) => { outStream.Close(); });
   }
   else
   {
       Console.WriteLine("Request Failed: Status: " + response.StatusCode + ", Reason: " + response.ReasonPhrase);
   }
}

// Requires "request" to be installed (see https://www.npmjs.com/package/request)
var request = require('request');
var fs = require('fs');

request.post({
  url: 'https://pt.vectorizer.ai/api/v1/vectorize',
  formData: {
    image: fs.createReadStream('example.jpeg'), // TODO: Replace with your image
    // TODO: Add more upload options here
  },
  auth: {user: 'xyz123', pass: '[secret]'},
  followAllRedirects: true,
  encoding: null
}, function(error, response, body) {
  if (error) {
    console.error('Request failed:', error);
  } else if (!response || response.statusCode != 200) {
    console.error('Error:', response && response.statusCode, body.toString('utf8'));
  } else {
    // Save result
    fs.writeFileSync("result.svg", body);
  }
});

$ch = curl_init('https://pt.vectorizer.ai/api/v1/vectorize');

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER,
    array('Authorization: Basic dmt5YzY3a3FhMjd5aWRkOltzZWNyZXRd'));
curl_setopt($ch, CURLOPT_POSTFIELDS,
    array(
      'image' => curl_file_create('example.jpeg'),
      // TODO: Add more upload options here
    ));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);

$data = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_HTTP_CODE) == 200) {
  // Save result
  file_put_contents("result.svg", $data);
} else {
  echo "Error: " . $data;
}
curl_close($ch);

# Either use the sample code below, or the official SDK: https://vectorizer.ai/api/documentation#sdks
# Requires "requests" to be installed (see https://pypi.org/project/requests/)
import requests

response = requests.post(
    'https://pt.vectorizer.ai/api/v1/vectorize',
    files={'image': open('example.jpeg', 'rb')},
    data={
        # TODO: Add more upload options here
    },
    auth=('xyz123', '[secret]')
)
if response.status_code == requests.codes.ok:
    # Save result
    with open('result.svg', 'wb') as out:
        out.write(response.content)
else:
    print("Error:", response.status_code, response.text)

# Requires: gem install httpclient
require 'httpclient'

client = HTTPClient.new default_header: {
  "Authorization" => "Basic dmt5YzY3a3FhMjd5aWRkOltzZWNyZXRd"
}

response = client.post("https://pt.vectorizer.ai/api/v1/vectorize", {
  "image" => File.open("example.jpeg", "rb"), # TODO: Replace with your image
  # TODO: Add more upload parameters here
})

if response.status == 200 then
  # Write result to disk, TODO: or wherever you'd like
  File.open("result.svg", 'w') { |file| file.write(response.body) }
else
  puts "Error: Code: " + response.status.to_s + ", Reason: " + response.reason
end

$ curl https://pt.vectorizer.ai/api/v1/vectorize \
 -u xyz123:[secret] \
 -F 'image.url=https://example.com/example.jpeg' \
 -o result.svg

// Requires: org.apache.httpcomponents.client5:httpclient5-fluent

Request request = Request.post("https://pt.vectorizer.ai/api/v1/vectorize")
   .addHeader("Authorization", "Basic dmt5YzY3a3FhMjd5aWRkOltzZWNyZXRd")
   .body(
      MultipartEntityBuilder.create()
         .addTextBody("image.url", "https://example.com/example.jpeg") // TODO: Replace with your image URL
         // TODO: Add more upload parameters here
         .build()
      );
ClassicHttpResponse response = (ClassicHttpResponse) request.execute().returnResponse();

if (response.getCode() == 200) {
   // Write result to disk, TODO: or wherever you'd like
   try (FileOutputStream out = new FileOutputStream("result.svg")) {
      response.getEntity().writeTo(out);
   }
} else {
   System.out.println("Request Failed: Status: " + response.getCode() + ", Reason: " + response.getReasonPhrase());
}

using (var client = new HttpClient())
using (var form = new MultipartFormDataContent())
{
   client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", "INSERT_API_KEY_HERE");
   form.Add(new StringContent("https://example.com/example.jpeg"), "image.url"); // TODO: Replace with your image URL
   // TODO: Add more upload parameters here

   var response = client.PostAsync("https://pt.vectorizer.ai/api/v1/vectorize", form).Result;

   if (response.IsSuccessStatusCode)
   {
      // Write result to disk, TODO: or wherever you'd like
      FileStream outStream = new FileStream("result.svg", FileMode.Create, FileAccess.Write, FileShare.None);
      response.Content.CopyToAsync(outStream).ContinueWith((copyTask) => { outStream.Close(); });
   }
   else
   {
       Console.WriteLine("Request Failed: Status: " + response.StatusCode + ", Reason: " + response.ReasonPhrase);
   }
}

// Requires "request" to be installed (see https://www.npmjs.com/package/request)
var request = require('request');
var fs = require('fs');

request.post({
  url: 'https://pt.vectorizer.ai/api/v1/vectorize',
  formData: {
    'image.url': 'https://example.com/example.jpeg', // TODO: Replace with your image
    // TODO: Add more upload options here
  },
  auth: {user: 'xyz123', pass: '[secret]'},
  followAllRedirects: true,
  encoding: null
}, function(error, response, body) {
  if (error) {
    console.error('Request failed:', error);
  } else if (!response || response.statusCode != 200) {
    console.error('Error:', response && response.statusCode, body.toString('utf8'));
  } else {
    // Save result
    fs.writeFileSync("result.svg", body);
  }
});

$ch = curl_init('https://pt.vectorizer.ai/api/v1/vectorize');

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER,
    array('Authorization: Basic dmt5YzY3a3FhMjd5aWRkOltzZWNyZXRd'));
curl_setopt($ch, CURLOPT_POSTFIELDS,
    array(
      'image.url' => 'https://example.com/example.jpeg',
      // TODO: Add more upload options here
    ));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);

$data = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_HTTP_CODE) == 200) {
  // Save result
  file_put_contents("result.svg", $data);
} else {
  echo "Error: " . $data;
}
curl_close($ch);

# Either use the sample code below, or the official SDK: https://vectorizer.ai/api/documentation#sdks
# Requires "requests" to be installed (see https://pypi.org/project/requests/)
import requests

response = requests.post(
    'https://pt.vectorizer.ai/api/v1/vectorize',
    data={
        'image.url': 'https://example.com/example.jpeg',
        # TODO: Add more upload options here
    },
    auth=('xyz123', '[secret]')
)
if response.status_code == requests.codes.ok:
    # Save result
    with open('result.svg', 'wb') as out:
        out.write(response.content)
else:
    print("Error:", response.status_code, response.text)

# Requires: gem install httpclient
require 'httpclient'

client = HTTPClient.new default_header: {
  "Authorization" => "Basic dmt5YzY3a3FhMjd5aWRkOltzZWNyZXRd"
}

response = client.post("https://pt.vectorizer.ai/api/v1/vectorize", {
  "image.url" => "https://example.com/example.jpeg", # TODO: Replace with your image URL
  # TODO: Add more upload parameters here
})

if response.status == 200 then
  # Write result to disk, TODO: or wherever you'd like
  File.open("result.svg", 'w') { |file| file.write(response.body) }
else
  puts "Error: Code: " + response.status.to_s + ", Reason: " + response.reason
end

Desenvolvedor: Chatbot

Criamos um ChatGPT personalizado que pode ajudar nas integrações de desenvolvedores do Vectorizer.AI entre SDKs, linha de comando, OpenAPI e API HTTP direta. Ele pode responder a perguntas sobre esses documentos e fornecer exemplos de código ou comandos em seu idioma preferido, adaptados ao seu caso de uso.

O chatbot está em versão beta e comete erros. Confira as respostas e peça a ele que revise o código para solucionar erros e omissões.

SDKs

Os SDKs oficiais são gerados a partir da especificação pública OpenAPI e usam a mesma autenticação HTTP Basic que as chamadas diretas à API. Elas são o ponto de partida recomendado para a maioria das integrações de aplicativos, e suas chamadas vetorizadas e de download retornam o conteúdo do arquivo, enquanto as chamadas de conta e exclusão retornam modelos JSON.

Todos os SDKs têm como alvo https://api.vectorizer.ai/api/v1 e envolvem os endpoints estáveis /vectorize, /download, /delete e /account.

Prefira SDKs para integrações de aplicativos. Para geradores personalizados, linguagens não suportadas ou trabalho direto com protocolos, use a especificação OpenAPI. A configuração do gerador está disponível no GitHub.

Baixe o manifesto das ferramentas do cliente

Linha de comando

O cliente oficial da linha de comando é um executável independente para Windows, macOS e Linux. Ele é destinado a shells, scripts, processamento em lote, fluxos de trabalho de controle de qualidade e usuários que desejam vetorizar imagens sem escrever código de aplicativo.

Baixe pacotes binários e Linux dos lançamentos do GitHub ou veja a fonte no GitHub. A CLI usa as mesmas credenciais de API, servidor e comportamento de endpoint que chamadas diretas de API e integrações de SDK.

export VECTORIZER_API_ID="your-api-id"
export VECTORIZER_API_SECRET="your-api-secret"

vectorizer vectorize logo.png -o logo.svg
vectorizer vectorize logo.png -o logo.pdf --format pdf
vectorizer download IMAGE_TOKEN -o logo.svg

Use os SDKs ao incorporar o Vectorizer.AI em um aplicativo e use o cliente de linha de comando quando a interface natural for um terminal, uma tarefa agendada ou um pipeline de processamento de arquivos.

Especificação OpenAPI

A API direta está disponível como uma especificação OpenAPI 3.0 para clientes gerados, validação de esquema e exploração de API. A mesma especificação também impulsiona o fluxo de trabalho oficial de geração de SDK.

A especificação declara https://api.vectorizer.ai/api/v1 como seu servidor, então os clientes gerados usam caminhos de endpoint como /vectorize, /download, /delete e /account.

Fluxos de trabalho de integração

Esses fluxos de trabalho se aplicam se você usa um SDK oficial, o cliente de linha de comando ou a API HTTP direta. Este são alguns dos comuns:

Imagem individual Envie um bitmap, receba um resultado vetorial. Pronto!

Chame o fluxo de trabalho do Vectorize diretamente, por meio de um SDK ou com o cliente de linha de comando.

Primeiro uma prévia Mostre um resultado prévio para o seu cliente potencial antes que ele faça a compra.

Se você precisar fazer muitas chamadas de serviço para fazer uma venda, poderá usar as visualizações de menor custo até realmente converter um cliente.

1. Chame Vectorize por meio de um SDK, cliente de linha de comando ou HTTP direto com mode=preview e policy.retention_days > 0 para obter a visualização, certificando-se de reter o token de imagem retornado no cabeçalho de resposta X-Image-Token.

2. Após a conversão, chame Download with the Image Token para baixar o resultado completo.

3. Opcional: se precisar do resultado em mais formatos (por exemplo, PNG, PDF, etc), mantenha o recibo retornado no cabeçalho de resposta do download X-Receipt. Em seguida, use o fluxo de trabalho de download com o token de imagem e o recibo para baixar os formatos restantes.

Múltiplos formatos Digamos que você precise do resultados nos formatos PNG e SVG.

1. Chame Vectorize com policy.retention_days > 0 para obter o primeiro resultado, certificando-se de reter o token de imagem retornado no cabeçalho de resposta X-Image-Token.

2. Chame Download com o Image Token para baixar os outros formatos.

Múltiplas opções Você quer processar cada imagem com múltiplas opções de processamento.

1. Chame Vectorize com policy.retention_days > 0 para obter o primeiro resultado, certificando-se de reter o token de imagem retornado no cabeçalho de resposta X-Image-Token.

2. Chame Vectorize com o Image Token para iterar as opções de processamento restantes de que você precisa.

Como alternativa, você pode processar cada imagem individualmente, sem se preocupar com o token da imagem. O token da imagem economiza um pouco de banda e latência.

Preços

Consulta os planos de assinatura na página de preços.

Autenticação e segurança

A API usa autenticação padrão HTTP básica de acesso. Todas as requisições para a API devem ser feitas em HTTPS e incluir suas credenciais da API, tendo API Id como usuário e API Secret como senha.

Os SDKs oficiais e o cliente de linha de comando usam essas mesmas credenciais e adicionam o cabeçalho de autenticação HTTP Basic para você.

Sua biblioteca de cliente HTTP deve aceitar Indicação de Nome do Servidor (SNI) para fazer requisições corretamente. Se você estiver recebendo erros de handshake estranhos, provavelmente esta é a causa.

Limitação de velocidade

O uso da API tem limite de taxa com margens generosas e não há tetos definitivos.

Durante as operações conduzidas pelo usuário final, é improvável que você tenha limitações de velocidade, pois o uso é adaptado pelo sistema de forma transparente.

No entanto, para trabalhos em lote, recomendamos começar com no máximo cinco ramificações e adicionar uma nova ramificação a cada cinco minutos, até atingir o nível de paralelismo desejado. Se você precisa de mais de 100 ramificações simultâneas, fale conosco antes de começar.

A maneira mais fácil de realizar esse aumento gradual no paralelismo é iniciar imediatamente o número de segmentos que você eventualmente deseja usar, mas depois usar um semáforo de contagem que comece com 5 permissões. Em seguida, você pode ter um tópico separado que aumenta o número de licenças em 1 a cada 5 minutos.

Se enviar requisições em excesso, você começará a receber respostas do tipo 429 Too Many Requests. Se isso ocorrer, você deverá aplicar um algoritmo de back off linear: na primeira resposta desse tipo, aguarde 5 segundos até reenviar a requisição seguinte. Na segunda resposta 429 consecutiva, aguarde 2 x 5=10 segundos até reenviar a requisição seguinte. Na terceira, aguarde 3 x 5=15 segundos, e assim por diante.

Você poderá reinicializar o contador de back off após o processamento satisfatório de uma requisição, e o back off deve ser aplicado ramificação a ramificação, ou seja, as ramificações devem operar independentemente.

Limite de tempo de inatividade

Em geral, as solicitações de API são executadas em segundos, mas é possível que o tempo de processamento seja mais longo durante picos de carga.

Para assegurar que sua biblioteca de cliente não encerre solicitações de API prematuramente, ela deveria ser configurada com um limite de tempo de inatividade mínimo de 180 segundos

O cliente oficial da linha de comando usa como padrão um tempo limite maior, mas o SDK personalizado e as integrações HTTP diretas ainda devem definir explicitamente um tempo limite apropriado.

Erro JSON

Usamos status HTTP convencionais para indicar êxito ou falha de uma requisição de API e incluir informações importantes sobre erro no objeto JSON de erro retornado.

Tentamos sempre retornar um objeto JSON de erro com qualquer requisição problemática. Teoricamente, no entanto, sempre é possível haver falhas internas no servidor que resultam em uma resposta de erro não JSON.

Se o status HTTP da sua requisição for 200, não haverá retorno de Objeto JSON de erro e você pode supor com segurança que a requisição foi, de forma geral, exitosa.

Algumas bibliotecas de cliente HTTP suscitam exceções para status HTTP no intervalo 400-599. Você deverá obter essas exceções e tratá-las adequadamente.

Os SDKs apresentam essas respostas malsucedidas como exceções nativas ou valores de erro, enquanto o cliente da linha de comando imprime os detalhes do erro da API como erro padrão.

{
  "error" : {
    "status" : 400,
    "code" : 1006,
    "message" : "Failed to read the supplied image. "
  }
}

Os erros de API recentes estão relacionados na página da sua conta para facilitar o debugging.

Também há uma lista de todas as respostas de erro retornadas pela API.

Cabeçalhos de resposta

Estes são os cabeçalhos de resposta utilizados:

Ao usar um SDK, use a variante do método com reconhecimento de cabeçalho se precisar de tokens de imagem, recibos, informações de crédito ou cabeçalhos de nova tentativa. Ao usar o cliente de linha de comando, os tokens e recibos de imagem são impressos com erro padrão para que a saída binária ainda possa ser gravada na saída padrão.

#00000000;
#FFFFFF ~ 0.1;
#0000FF -> #00FF00;
#FF0000 -> #00FF00 ~ 0.1;

#FF0000; 
#00FF00; 
#0000FF;

#FF0000 ~ 0.02; 
#00FF00 ~ 0.02; 
#0000FF ~ 0.02;

#FF0000 -> #00FF00 ~ 0.02;

#FF0000 ~ 0.02; 
#00FF00 ~ 0.02; 
#0000FF ~ 0.02; 
#00000000; // Transparent => removed

{
  "success" : true
}

$ curl "https://api.vectorizer.ai/api/v1/account" \
 -u vkyc67kqa27yidd:[secret]

{
  "subscriptionPlan" : "none",
  "subscriptionState" : "ended",
  "credits" : 0
}

Registro de alterações do desenvolvedor

• Visão geral do desenvolvedor
• Documentação
• Opções para resultados
• Respostas de erro