Image Denoise API

Copyimport requests

response = requests.post(
    "https://precisioncounter.com/api/v1/denoise-image",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    files={"image": open("noisy_photo.jpg", "rb")},
    data={"strength": "medium"}
)

with open("denoised.png", "wb") as f:
    f.write(response.content)

Copyconst fs = require("fs");
const FormData = require("form-data");

const form = new FormData();
form.append("image", fs.createReadStream("noisy_photo.jpg"));
form.append("strength", "medium");

const response = await fetch(
  "https://precisioncounter.com/api/v1/denoise-image",
  {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      ...form.getHeaders()
    },
    body: form
  }
);

const buffer = Buffer.from(await response.arrayBuffer());
fs.writeFileSync("denoised.png", buffer);

Copyconst fs = require("fs");
const FormData = require("form-data");
const fetch = require("node-fetch");

const API_KEY = "YOUR_API_KEY";
const API_URL = "https://precisioncounter.com/api/v1/denoise-image";

async function denoiseImage(inputPath, outputPath = "denoised.png", strength = "medium") {
  const form = new FormData();
  form.append("image", fs.createReadStream(inputPath));
  form.append("strength", strength);
  form.append("preserve_detail", "true");

  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      ...form.getHeaders()
    },
    body: form
  });

  if (response.ok) {
    const buffer = Buffer.from(await response.arrayBuffer());
    fs.writeFileSync(outputPath, buffer);
    console.log(`Saved to ${outputPath}`);
    console.log(`Credits: ${response.headers.get("x-credits-remaining")}`);
  } else {
    const error = await response.json();
    console.error(`Error ${response.status}: ${error.error}`);
  }
}

denoiseImage("noisy_photo.jpg", "denoised.png", "strong");

Copy<?php
$api_key = "YOUR_API_KEY";
$url = "https://precisioncounter.com/api/v1/denoise-image";

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer $api_key"
    ],
    CURLOPT_POSTFIELDS => [
        "image" => new CURLFile("noisy_photo.jpg"),
        "strength" => "medium",
        "preserve_detail" => "true"
    ]
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode === 200) {
    file_put_contents("denoised.png", $response);
    echo "Image denoised successfully\n";
} else {
    echo "Error $httpCode: $response\n";
}
?>

Copypackage main

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

func denoiseImage(inputPath, outputPath, strength string) error {
    file, _ := os.Open(inputPath)
    defer file.Close()

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, _ := writer.CreateFormFile("image", inputPath)
    io.Copy(part, file)
    writer.WriteField("strength", strength)
    writer.WriteField("preserve_detail", "true")
    writer.Close()

    req, _ := http.NewRequest("POST",
        "https://precisioncounter.com/api/v1/denoise-image", body)
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", writer.FormDataContentType())

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    if resp.StatusCode == 200 {
        out, _ := os.Create(outputPath)
        defer out.Close()
        io.Copy(out, resp.Body)
        fmt.Printf("Saved to %s\n", outputPath)
    }
    return nil
}

func main() {
    denoiseImage("noisy_photo.jpg", "denoised.png", "medium")
}

Copyrequire "net/http"
require "uri"

api_key = "YOUR_API_KEY"
uri = URI("https://precisioncounter.com/api/v1/denoise-image")

form_data = [
  ["image", File.open("noisy_photo.jpg", "rb")],
  ["strength", "medium"],
  ["preserve_detail", "true"]
]

req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{api_key}"
req.set_form(form_data, "multipart/form-data")

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(req)
end

if res.code == "200"
  File.binwrite("denoised.png", res.body)
  puts "Image denoised successfully"
else
  puts "Error #{res.code}: #{res.body}"
end

Copyusing var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

using var form = new MultipartFormDataContent();
var imageContent = new ByteArrayContent(File.ReadAllBytes("noisy_photo.jpg"));
imageContent.Headers.ContentType = new("image/jpeg");
form.Add(imageContent, "image", "noisy_photo.jpg");
form.Add(new StringContent("medium"), "strength");
form.Add(new StringContent("true"), "preserve_detail");

var response = await client.PostAsync(
    "https://precisioncounter.com/api/v1/denoise-image", form);

if (response.IsSuccessStatusCode)
{
    var result = await response.Content.ReadAsByteArrayAsync();
    File.WriteAllBytes("denoised.png", result);
    Console.WriteLine("Image denoised successfully");
}