Virtual Try-On API

Copyimport requests

api_url = 'https://precisioncounter.com/api/v1/virtual-try-on'
files = {'image': open('path/to/image.jpg', 'rb')}
data = {'user_attributes': '{"skin_tone":"light"}', 'category': 'glasses'}
headers = {'Authorization': 'Bearer YOUR_API_KEY'}
response = requests.post(api_url, files=files, data=data, headers=headers)
print(response.json())

Copyconst fetch = require('node-fetch');
const fs = require('fs');

const apiUrl = 'https://precisioncounter.com/api/v1/virtual-try-on';
const formData = new FormData();
formData.append('image', fs.createReadStream('path/to/image.jpg'));
formData.append('user_attributes', '{"skin_tone":"light"}');
formData.append('category', 'glasses');

fetch(apiUrl, {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
  body: formData
})
  .then(response => response.json())
  .then(data => console.log(data));

Copyconst fetch = require('node-fetch');
const fs = require('fs');

async function virtualTryOn(imagePath, userAttributes, category) {
  const apiUrl = 'https://precisioncounter.com/api/v1/virtual-try-on';
  const formData = new FormData();
  formData.append('image', fs.createReadStream(imagePath));
  formData.append('user_attributes', userAttributes);
  formData.append('category', category);

  try {
    const response = await fetch(apiUrl, {
      method: 'POST',
      headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
      body: formData
    });
    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error:', error);
  }
}

// Example Usage
virtualTryOn('path/to/image.jpg', '{"skin_tone":"light"}', 'glasses');

Copy<?php
function virtual_try_on($image_path, $user_attributes, $category) {
    $api_url = 'https://precisioncounter.com/api/v1/virtual-try-on';
    $curl = curl_init();
    $headers = ['Authorization: Bearer YOUR_API_KEY'];

    $file = new CURLFile($image_path);
    $postFields = array('image' => $file, 'user_attributes' => $user_attributes, 'category' => $category);

    curl_setopt_array($curl, [
        CURLOPT_URL => $api_url,
        CURLOPT_POST => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POSTFIELDS => $postFields,
        CURLOPT_HTTPHEADER => $headers
    ]);

    $response = curl_exec($curl);
    $httpcode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
    curl_close($curl);

    if ($httpcode >= 200 && $httpcode < 300) {
        return json_decode($response, true);
    } else {
        return 'Request failed with status code ' . $httpcode;
    }
}

// Example Usage
$result = virtual_try_on('path/to/image.jpg', '{"skin_tone":"light"}', 'glasses');
print_r($result);
?>

Copypackage main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"mime/multipart"
	"net/http"
	"os"
)

func virtualTryOn(imagePath, userAttributes, category string) {
	apiUrl := "https://precisioncounter.com/api/v1/virtual-try-on"

	file, err := os.Open(imagePath)
	if err != nil {
		fmt.Println("Error opening file:", err)
		return
	}
	defer file.Close()

	var requestBody bytes.Buffer
	writer := multipart.NewWriter(&requestBody)
	part, err := writer.CreateFormFile("image", file.Name())
	if err != nil {
		fmt.Println("Error creating form file:", err)
		return
	}
	_, err = io.Copy(part, file)

	_ = writer.WriteField("user_attributes", userAttributes)
	_ = writer.WriteField("category", category)

	writer.Close()

	req, err := http.NewRequest("POST", apiUrl, &requestBody)
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}
	req.Header.Add("Content-Type", writer.FormDataContentType())
	req.Header.Add("Authorization", "Bearer YOUR_API_KEY")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error sending request:", err)
		return
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Error reading response body:", err)
		return
	}
	fmt.Println(string(body))
}

func main() {
	virtualTryOn("path/to/image.jpg", "{\"skin_tone\":\"light\"}", "glasses")
}

Copyrequire 'net/http'
require 'uri'
require 'json'
require 'mime'

uri = URI.parse('https://precisioncounter.com/api/v1/virtual-try-on')

request = Net::HTTP::Post.new(uri)
request.content_type = 'multipart/form-data'
request['Authorization'] = 'Bearer YOUR_API_KEY'

form_data = [['image', File.open('path/to/image.jpg')]]
form_data << ['user_attributes', '{"skin_tone":"light"}']
form_data << ['category', 'glasses']

request.set_form form_data, 'multipart/form-data'

req_options = { use_ssl: uri.scheme == 'https' }

response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

puts response.body

Copyusing System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        string apiUrl = "https://precisioncounter.com/api/v1/virtual-try-on";
        var client = new HttpClient();
        var form = new MultipartFormDataContent();
        form.Add(new ByteArrayContent(System.IO.File.ReadAllBytes("path/to/image.jpg")), "image", "image.jpg");
        form.Add(new StringContent("{\"skin_tone\":\"light\"}"), "user_attributes");
        form.Add(new StringContent("glasses"), "category");

        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "YOUR_API_KEY");

        try
        {
            var response = await client.PostAsync(apiUrl, form);
            response.EnsureSuccessStatusCode();
            string content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Request error: {e.Message}");
        }
    }
}