DelphiStabilityAI
v1.0.0
Stability.ai is a well-established organization in artificial intelligence, known for its models that generate images and text from descriptions. Below is a summary of the key models they have developed, presented in chronological order of release:
Image Generation Models:
Stable Diffusion (August 2022)
The first latent diffusion model, capable of generating images based on textual descriptions.
Stable Diffusion 2.0 (November 2022)
An updated version with improved image quality, support for higher resolutions, and additional features.
Stable Diffusion XL (SDXL) (April 2023)
Focused on photorealism, this version introduced improvements in image composition and face generation.
Stable Diffusion 3.0 (February 2024)
Featuring a new architecture that combines diffusion transformers and flow matching, this version enhances performance for multi-subject queries and overall image quality.
Stable Cascade (February 2024)
Built on the Würstchen architecture, this model improves accuracy and efficiency in text-to-image generation.
Stable Diffusion 3.5 (October 2024)
Includes variants such as Stable Diffusion 3.5 Large and 3.5 Medium, offering more options for diverse generation tasks with optimized efficiency.
Important
This is an unofficial library. Stability.ai does not provide any official library for Delphi.
This repository contains Delphi implementation over Stability.ai public API.
You can access the Stability.ai console to explore the available possibilities.
To obtain an API key, you need to create an account. A credit of 25 will be granted to you, and an initial key will be automatically generated. You can find this key here.
Once you have a token, you can initialize IStabilityAI interface, which is an entry point to the API.
Note
uses StabilityAI;
var Stability := TStabilityAIFactory.CreateInstance(API_KEY);Warning
To use the examples provided in this tutorial, especially to work with asynchronous methods, I recommend defining the stability interface with the widest possible scope.
So, set Stability := TStabilityAIFactory.CreateInstance(API_KEY); in the OnCreate event of your application.
Where Stability: IStabilityAI;
In the context of asynchronous methods, for a method that does not involve streaming, callbacks use the following generic record: TAsynCallBack<T> = record defined in the StabilityAI.Async.Support.pas unit. This record exposes the following properties:
TAsynCallBack<T> = record
...
Sender: TObject;
OnStart: TProc<TObject>;
OnSuccess: TProc<TObject, T>;
OnError: TProc<TObject, string>; The name of each property is self-explanatory; if needed, refer to the internal documentation for more details.
Note
In the rest of the tutorial, we will primarily use anonymous methods unless otherwise specified, as working with APIs requires it due to processing times that can sometimes be quite long.
Stable Image Ultra use the Diffusion 3.5 model. This method is distinguished by:
Asynchronous Code Example
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate;
Stability.StableImage.Generate.ImageUltra(
procedure (Params: TStableImageUltra)
begin
Params.AspectRatio(ratio16x9);
Params.Prompt('Lighthouse on a cliff overlooking the ocean');
//A blurb of text describing what you do not wish to see in the output image.
//Params.NegativePrompt('...')
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
//Add a TImage on the form
//Add a TMemo on the form
Result.Sender := Image1;
Result.OnStart :=
procedure (Sender: TObject)
begin
Memo1.Lines.Text := Memo1.Text + 'The generation has started. Please wait...' + sLineBreak;
end;
Result.OnSuccess :=
procedure (Sender: TObject; Image: TStableImage)
begin
var Stream := Image.GetStream;
try
Image.SaveToFile('lighthouse.png');
//for VCL
Image1.Picture.LoadFromStream(Stream);
//for FMX
//Image1.Bitmap.LoadFromStream(Stream);
Memo1.Lines.Text := Memo1.Text + 'Generation ended successfully' + sLineBreak;
finally
Stream.Free;
end;
end;
Result.OnError :=
procedure (Sender: TObject; Error: String)
begin
Memo1.Lines.Text := Memo1.Text + Error + sLineBreak;
end;
end);Detailed settings on the official documentation
To simplify the example codes provided in this tutorial, I have included two units in the source code: VCL.Stability.Tutorial and FMX.Stability.Tutorial. Depending on the option you choose to test the provided source code, you will need to instantiate either the TVCLStabilitySender or TFMXStabilitySender class in the application's OnCreate event, as follows:
Tip
//uses VCL.Stability.Tutorial;
StabilityResult := TVCLStabilitySender.Create(Memo1, Image1);or
//uses FMX.Stability.Tutorial;
StabilityResult := TFMXStabilitySender.Create(Memo1, Image1);Make sure to add a TMemo and a TImage component to your form beforehand.
It is also possible to provide a reference image to use as a starting point for generation. In this case, the strength parameter must be specified, as it determines the influence of the input image on the final output. A strength value of 0 will produce an image identical to the input, while a value of 1 indicates no influence from the initial image.
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial;
StabilityResult.FileName := 'lighthouse1.png';
Stability.StableImage.Generate.ImageUltra(
procedure (Params: TStableImageUltra)
begin
Params.AspectRatio(ratio16x9);
Params.Prompt('There are many birds in the sky');
Params.Image('lighthouse.png');
Params.Strength(0.3);
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Specificity:
Stable Image Core is a text-to-image generation service designed to deliver premium quality with speed. Unlike other similar tools, it requires no expertise in "prompt engineering." Users simply describe a style, scene, or character, and the tool generates an image that aligns with their description.Key Points:
Applications Inventory:
Asynchronous Code Example
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial;
StabilityResult.FileName := 'lighthouse2.png';
Stability.StableImage.Generate.ImageCore(
procedure (Params: TStableImageCore)
begin
Params.AspectRatio(ratio16x9);
Params.Prompt('Lighthouse on a cliff overlooking the ocean');
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
You can guide the image model toward a specific style by selecting from 17 available styles.
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial;
StabilityResult.FileName := 'lighthouse3.png';
Stability.StableImage.Generate.ImageCore(
procedure (Params: TStableImageCore)
begin
Params.AspectRatio(ratio16x9);
Params.Prompt('Lighthouse on a cliff overlooking the ocean');
Params.StylePreset(TStylePreset.digitalArt);
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Inventory of available models
Stable Diffusion 3.5
Stable Diffusion 3.0 (Fireworks AI)
Key Points:
Turbo versions generate images faster without sacrificing quality.This mode creates an image based solely on a textual description. The prompt is the only mandatory input, but an optional aspect_ratio parameter is available to adjust the dimensions of the resulting image.
Asynchronous Code Example
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial;
StabilityResult.FileName := 'lighthouse4.png';
Stability.StableImage.Generate.Diffusion(
procedure (Params: TStableImageDiffusion)
begin
Params.AspectRatio(ratio16x9);
Params.Prompt('Lighthouse on a cliff overlooking the ocean');
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
This method generates an image based on text input while using an existing image as the initial reference. The necessary parameters include:
prompt: the descriptive text that guides the image generation.image: the starting image that serves as the foundation for the output.strength: determines the degree to which the starting image influences the final result.mode: should be set to "image-to-image".Asynchronous Code Example
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial;
StabilityResult.FileName := 'lighthouse5.png';
Stability.StableImage.Generate.Diffusion(
procedure (Params: TStableImageDiffusion)
begin
Params.Prompt('There are many birds in the sky');
Params.Mode(imageToImage);
Params.Image('lighthouse4.png');
Params.Strength(0.6);
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Note
Note: maximum request size is 10MiB.
Both modes allow the use of these optional parameters:
model: Specifies the model to utilize, such as SD3 Large, SD3 Large Turbo, or SD3 Medium.output_format: Determines the desired format of the resulting image.seed: Sets the randomness seed for the generation process.negative_prompt: Defines keywords to exclude from the generated image.cfg_scale: Adjusts the level of adherence to the prompt text during the diffusion process.Using SDXL 1.0: Use stable-diffusion-xl-1024-v1-0 as the engine_id for your request, and specify the dimensions (height and width) with one of the following combinations:
Using SD 1.6: SD 1.6 is a flexible-resolution base model designed for generating images with non-standard aspect ratios. The model is optimized for a resolution of 512 x 512 pixels. To create outputs with a resolution of 1 megapixel, we recommend using SDXL 1.0, which is available at the same price.
To use this model, set stable-diffusion-v1-6 as the engine_id in your request and ensure the height and width meet the following requirements:
Asynchronous Code Example
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate,
// StabilityAI.Version1.SDXL1AndSD1_6, FMX.Stability.Tutorial;
StabilityResult.FileName := 'lighthouse6.png';
Stability.Version1.SDXLAndSDL.TextToImage('stable-diffusion-xl-1024-v1-0',
procedure (Params: TPayload)
begin
Params.TextPrompts([TPrompt.New(1, 'A lighthouse on a cliff') ]);
Params.CfgScale(7);
Params.Height(1216);
Params.Width(832);
Params.Sampler(TSamplerType.K_DPMPP_2S_ANCESTRAL);
Params.Samples(1);
Params.Steps(30);
end,
function : TAsynArtifacts
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
Adjusting the Degree of Transformation
init_image_mode=IMAGE_STRENGTH with image_strength=0.35, or use init_image_mode=STEP_SCHEDULE with step_schedule_start=0.65. Both methods yield similar results, but the step_schedule mode offers additional flexibility by allowing you to specify a step_schedule_end value, giving more nuanced control if needed. For further details, refer to the specific parameter descriptions below.Asynchronous Code Example
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate,
// StabilityAI.Version1.SDXL1AndSD1_6, FMX.Stability.Tutorial;
StabilityResult.FileName := 'lighthouse7.png';
Stability.Version1.SDXLAndSDL.ImageToImageWithPrompt('stable-diffusion-v1-6',
procedure (Params: TPayloadPrompt)
begin
Params.TextPrompts([TPromptMultipart.New(1, 'A dog space commander') ]);
Params.InitImage('lighthouse6.png');
Params.ImageStrength(0.45);
Params.CfgScale(7);
Params.Sampler(TSamplerType.K_DPMPP_2S_ANCESTRAL);
Params.Samples(3);
Params.Steps(30);
end,
function : TAsynArtifacts
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Tip
In our code example, the value of the Samples parameter is 3, which means that three images were generated. Only the first one is displayed. The other two were saved with indexed file names as follows: lighthouse701.png and lighthouse702.png.
Detailed settings on the official documentation
Modify specific parts of an image using a mask. The mask must match the dimensions and shape of the original image. This functionality also supports images with alpha channels.
use the métode:
ImageToImageWithMask(const Model: string; ParamProc: TProc<TPayloadMask>;
CallBacks: TFunc<TAsynArtifacts>);Tools to Enhance the Size and Resolution of Your Images
Conservative Upscaler
Creative Upscaler
Fast Upscaler
Accepts images ranging in size from 64x64 pixels up to 1 megapixel and enhances their resolution to 4K. More broadly, it can upscale images by approximately 20 to 40 times while maintaining their original details. The Conservative Upscale option focuses on preserving the image's integrity with minimal modifications and is not intended for reinterpreting the image's content.
Asynchronous Code Example
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Upscale;
StabilityResult.FileName := 'Upscalelighthouse1.png';
Stability.StableImage.Upscale.Conservative(
procedure (Params: TUpscaleConservative)
begin
Params.Image('lighthouse.png');
Params.Prompt('The light house');
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
Accepts images ranging from 64x64 pixels to a maximum of 1 megapixel, enhancing their resolution up to 4K. More broadly, it can upscale images by approximately 20 to 40 times while maintaining—and often improving—their quality. The Creative Upscale feature is particularly effective for heavily degraded images, but it is not suited for photos larger than 1 megapixel, as it applies significant reinterpretation (adjustable via the creativity scale).
Warning
This function is labeled as asynchronous by the editor, but in reality, it doesn't behave as such for a third-party application utilizing it. It operates more like a caching mechanism for a slightly delayed processing.
Asynchronous Code Example
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Upscale;
Stability.StableImage.Upscale.Creative(
procedure (Params: TUpscaleCreative)
begin
Params.Image('lighthouse.png');
Params.Prompt('The gray light house');
Params.OutputFormat(png);
end,
function : TAsynResults
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
We retrieve the job ID, and in the next step, we need to load the image unless the status retrieved is "in-progress." In that case, the operation should be retried.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Results,
// e.g. Id ---> ea771536f066b7fd03d62384581982ecd8b54a932a6378d5809d43f6e5aa789a
StabilityResult.FileName := 'Upscalelighthouse2.png';
Stability.StableImage.Results.Fetch(StabilityResult.Id,
function : TAsynResults
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
The Fast Upscaler serviceincrease image resolution by 400%. Designed for speed and efficiency, it processes images in approximately one second, making it an excellent tool for improving the clarity of compressed visuals, perfect for social media posts and various other uses.
Asynchronous Code Example
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Upscale;
StabilityResult.FileName := 'Upscalelighthouse3.png';
Stability.StableImage.Upscale.Fast(
procedure (Params: TUpscaleFast)
begin
Params.Image('lighthouse.png');
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
Feature Inventory
The Erase service is designed to eliminate unwanted elements from images, such as imperfections on faces or objects on surfaces, using masking techniques.
Masks can be supplied in one of two methods:
mask parameter.Asynchronous Code Example
Note
mask is supplied, a mask will automatically be generated based on the image's alpha channel. Transparent areas will be subject to inpainting, while opaque regions will remain unchanged.mask, the mask will override the alpha channel.//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Edit;
StabilityResult.FileName := 'EraseLighthouse.png';
Stability.StableImage.Edit.Erase(
procedure (Params: TErase)
begin
Params.Image('Lighthouse.png');
Params.OutputFormat(png);
end,
function: TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);When a mask is provided :
Note
mask's dimensions differ from those of the image parameter, it will be automatically adjusted to match the image size. Stability.StableImage.Edit.Erase(
procedure (Params: TErase)
begin
Params.Image('Lighthouse.png');
Params.Mask('MyMask01.png');
Params.GrowMask(6);
Params.OutputFormat(png);
end,
...Detailed settings on the official documentation
Modify images intelligently by adding or replacing specific sections with new content, guided by a mask image.
This mask can be supplied in two ways:
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Edit;
StabilityResult.FileName := 'InpaintLighthouse.png';
Stability.StableImage.Edit.Inpaint(
procedure (Params: TInpaint)
begin
Params.Image('Lighthouse.png');
Params.Mask('Mask01.png');
Params.Prompt('The lighthouse is bigger');
Params.OutputFormat(png);
end,
function: TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);The use of the mask is identical to that described with the erase API.
Detailed settings on the official documentation
The Outpaint service allows for the seamless extension of an image by adding content in any direction to fill the surrounding space. Unlike other methods, whether automated or manual, this service is designed to reduce visible artifacts and avoid noticeable indications of image editing.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Edit;
StabilityResult.FileName := 'OutpaintLighthouse.png';
Stability.StableImage.Edit.Outpaint(
procedure (Params: TOutpaint)
begin
Params.Image('Lighthouse.png');
Params.Right(200);
Params.Down(400);
Params.OutputFormat(png);
end,
function: TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
The Search and Replace service offers a specialized form of inpainting that eliminates the need for a mask. Instead, users can specify an object to replace by describing it in plain language using a search_prompt. The service will then automatically detect and segment the specified object, seamlessly substituting it with the one described in the prompt.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Edit;
StabilityResult.FileName := 'SearchReplaceLighthouse.png';
Stability.StableImage.Edit.SearchAndReplace(
procedure (Params: TSearchAndReplace)
begin
Params.Image('Lighthouse.png');
Params.Prompt('Replace the lighthouse');
Params.SearchPrompt('Lighthouse');
Params.OutputFormat(png);
end,
function: TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
By utilizing the Search and Recolor service, you can change the color of a specific object in an image through a simple prompt. This specialized form of inpainting doesn't require a mask. Instead, the service automatically segments the object and applies the new colors as specified in your prompt.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Edit;
StabilityResult.FileName := 'SearchRecolorLighthouse.png';
Stability.StableImage.Edit.SearchAndRecolor(
procedure (Params: TSearchAndRecolor)
begin
Params.Image('Lighthouse.png');
Params.Prompt('The lighthouse is pink');
Params.SelectPrompt('Lighthouse');
Params.OutputFormat(png);
end,
function: TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
The Remove Background service precisely identifies and isolates the foreground in an image, allowing for the background to be either removed or replaced as needed.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Edit;
StabilityResult.FileName := 'RemoveBackgroundLighthouse.png';
Stability.StableImage.Edit.RemoveBackground(
procedure (Params: TRemoveBackground)
begin
Params.Image('Lighthouse.png');
Params.OutputFormat(png);
end,
function: TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
The Replace Background and Relight editing service enables to effortlessly change backgrounds using AI-generated images or their own uploads, while seamlessly adjusting lighting to complement the subject. This API offers an efficient image editing solution tailored for various industries, including e-commerce, real estate, photography, and creative endeavors.
Key features include:
Warning
This function is labeled as asynchronous by the editor, but in reality, it doesn't behave as such for a third-party application utilizing it. It operates more like a caching mechanism for a slightly delayed processing.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Edit;
Stability.StableImage.Edit.ReplaceBackgroundAndRelight(
procedure (Params: TReplaceBackgroundAndRelight)
begin
Params.SubjectImage('Lighthouse.png');
Params.BackgroundPrompt('cinematic lighting');
Params.OutputFormat(png);
end,
function: TAsynResults
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);The API returns the ID of the ongoing task, just like the Upscale Creative API. You then need to use the Fetch API, as previously mentioned.
Detailed settings on the official documentation
Tools for Creating Controlled Variations of Images and Sketches
This tool is designed for development workflows involving iterative design and brainstorming. It transforms hand-drawn sketches into polished visuals with precise adjustments. Additionally, it enables fine-tuned control over the final appearance of non-sketch images by utilizing the image's contours and edges.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Control;
StabilityResult.FileName := 'Control01.png';
Stability.StableImage.Control.Sketch(
procedure (Params: TSketch)
begin
Params.Image('lighthouse.png');
Params.ControlStrength(0.7);
Params.Prompt('a medieval castle on a hill');
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
This service is designed to generate images while preserving the structure of an input image, making it particularly useful for tasks like replicating scenes or rendering characters based on predefined models.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Control;
StabilityResult.FileName := 'Control02.png';
Stability.StableImage.Control.Structure(
procedure (Params: TStructure)
begin
Params.Image('lighthouse.png');
Params.ControlStrength(0.7);
Params.Prompt('a well manicured shrub in an english garden');
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
This tool analyzes the stylistic features of a given input image (control image) and applies them to generate a new image guided by a specified prompt. The output image retains the visual style of the control image while incorporating the requested content.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.StableImage.Control;
StabilityResult.FileName := 'Control03.png';
Stability.StableImage.Control.Style(
procedure (Params: TStyle)
begin
Params.Image('lighthouse.png');
Params.Prompt('a majestic portrait of a chicken');
Params.Fidelity(0.7);
Params.OutputFormat(png);
end,
function : TAsynStableImage
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
Tools for fetching the results of your async generations.
For using, see Fetch async generation result
Stable Fast 3D generates high-quality 3D assets from a single 2D input image.
See the GLB File Format Specification for more details.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.VideoAnd3D.Stable3D;
StabilityResult.FileName := 'My_Result.gltf';
Stability.VideoAnd3D.Model3D.Fast3D(
procedure (Params: TStable3D)
begin
Params.Image('My_ImageTo3D.png');
Params.ForegroundRatio(0.85);
end,
function : TAsynModel3D
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
Use Stable Video Diffusion, a latent video diffusion model, to generate a short video from an initial image.
ID from the response to check the results at the image-to-video/result/{id} endpoint. Be sure not to poll this endpoint more than once every 10 seconds to avoid errors or rate-limiting issues.//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.VideoAnd3D.Video;
Stability.VideoAnd3D.ImageToVideo.Generation(
procedure (Params: TVideo)
begin
Params.Image('lighthouse1024x576.png');
end,
function : TAsynJobVideo
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);At the end, we retrieve the ID (e.g. d4fb4aa8301aee0b368a41b3c0a78018dfc28f1f959a3666be2e6951408fb8e3) of the video creation task. Then, we simply retrieve the result in this way.
Detailed settings on the official documentation
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.VideoAnd3D.Video;
var Id := 'd4fb4aa8301aee0b368a41b3c0a78018dfc28f1f959a3666be2e6951408fb8e3';
StabilityResult.FileName := 'lighthouse1024x576.mp4';
Stability.VideoAnd3D.ImageToVideo.Fetch(Id,
function : TAsynResults
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
List the engines compatible with Version 1 REST API endpoints.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.Version1.Engines;
Stability.Version1.Engines.List(
function : TAsynEngines
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
Retrieve details about the account linked to the specified API key
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.Version1.User;
Stability.Version1.User.AccountDetails(
function : TAsynAccountDetails
begin
Result.Sender := StabilityResult;
Result.OnStart := Start;
Result.OnSuccess := Display;
Result.OnError := Display;
end);Detailed settings on the official documentation
Retrieve the credit balance for the account or organization linked to the provided API key.
//uses
// StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial,
// StabilityAI.Version1.User;
var Balance := Stability.Version1.User.AccountBalance;
try
Memo1.Lines.Text := Memo1.Text + Balance.Credits.ToString + sLineBreak;
finally
Balance.Free;
end;Detailed settings on the official documentation
Stability.ai has announced two upcoming features:
Stable LLM 12B and Stable LLM 1.6B.Audio Stable 2.0. You can contact Stability.ai to test this model by sending a message.Pull requests are welcome. If you're planning to make a major change, please open an issue first to discuss your proposed changes.
This project is licensed under the MIT License.
