Generate Face recognition Hairstyle Variations with .NET and OpenAI

Generate Hairstyle Variations with .NET and OpenAI

Have you ever wanted to visualize how you'd look with a new hairstyle without actually visiting a salon? In this guide, we’ll walk you through creating a .NET application that uses OpenAI to generate hairstyle variations from an uploaded face image. This solution is perfect for experimenting with your look virtually, using the latest in AI technology.

Step 1: Set Up the .NET Environment

Start by creating a new ASP.NET Core Web API project. Install the required NuGet packages:

• Microsoft.AspNetCore.Mvc
• Newtonsoft.Json
• HttpClient

Optionally, you can install an OpenAI SDK for .NET, such as OpenAI-DotNet:

dotnet add package OpenAI-DotNet
    

Step 2: Upload and Process the Face Image

Here’s how you can create an API endpoint for uploading an image. This endpoint saves the file to a designated folder:

Controller Code for Image Upload:

[ApiController]
[Route("api/[controller]")]
public class ImageController : ControllerBase
{
    private readonly IWebHostEnvironment _environment;

    public ImageController(IWebHostEnvironment environment)
    {
        _environment = environment;
    }

    [HttpPost("upload")]
    public IActionResult UploadImage(IFormFile file)
    {
        if (file != null && file.ContentType.StartsWith("image"))
        {
            var uploadsFolder = Path.Combine(_environment.WebRootPath, "uploads");
            if (!Directory.Exists(uploadsFolder)) Directory.CreateDirectory(uploadsFolder);

            var filePath = Path.Combine(uploadsFolder, file.FileName);
            using (var fileStream = new FileStream(filePath, FileMode.Create))
            {
                file.CopyTo(fileStream);
            }

            return Ok(new { Path = filePath });
        }

        return BadRequest("Invalid image file.");
    }
}
    

Step 3: Generate Hairstyles with OpenAI

The OpenAI API is used to generate variations of the uploaded face image. Below is the service that interacts with OpenAI:

OpenAI Service Code:

public class OpenAiService
{
    private readonly HttpClient _httpClient;
    private const string OpenAiApiKey = "YOUR_API_KEY";

    public OpenAiService()
    {
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {OpenAiApiKey}");
    }

    public async Task> GenerateHairstyleVariations(string imagePath)
    {
        var imageBytes = await File.ReadAllBytesAsync(imagePath);
        var imageBase64 = Convert.ToBase64String(imageBytes);

        var requestBody = new
        {
            prompt = "Transform the face with different hairstyles: short straight hair, long wavy hair, curly hair with bangs, pixie cut, and a colorful mohawk.",
            image = imageBase64,
            n = 5,
            size = "1024x1024"
        };

        var content = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(requestBody), Encoding.UTF8, "application/json");
        var response = await _httpClient.PostAsync("https://api.openai.com/v1/images/edits", content);

        if (response.IsSuccessStatusCode)
        {
            var responseString = await response.Content.ReadAsStringAsync();
            var result = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(responseString);

            return result.data.ToObject<List<string>>();
        }

        throw new Exception("Failed to generate hairstyle variations.");
    }
}
    

Step 4: Display the Results

Finally, create an endpoint to call the OpenAI service and return the hairstyle images to the frontend:

Controller Code for Generating Variations:

[ApiController]
[Route("api/[controller]")]
public class OpenAiController : ControllerBase
{
    private readonly OpenAiService _openAiService;

    public OpenAiController()
    {
        _openAiService = new OpenAiService();
    }

    [HttpPost("generate-hairstyles")]
    public async Task GenerateHairstyleVariations([FromBody] string imagePath)
    {
        try
        {
            var variations = await _openAiService.GenerateHairstyleVariations(imagePath);
            return Ok(variations);
        }
        catch (Exception ex)
        {
            return StatusCode(500, ex.Message);
        }
    }
}
    

Conclusion

This application integrates .NET and OpenAI to create a dynamic tool for generating hairstyle variations. Whether you’re experimenting with your look or developing a creative app, this solution showcases the power of combining modern AI with robust .NET backend capabilities.