DelphiStabilityAI
v1.0.0
Stability.ai est une organisation bien établie en intelligence artificielle, connue pour ses modèles qui génèrent des images et du texte à partir de descriptions. Vous trouverez ci-dessous un résumé des modèles clés qu'ils ont développés, présentés dans l'ordre chronologique de la libération:
Modèles de génération d'images:
Stable Diffusion (août 2022) Le premier modèle de diffusion latente, capable de générer des images basées sur des descriptions textuelles.
Stable Diffusion 2.0 (novembre 2022) Une version mise à jour avec une qualité d'image améliorée, une prise en charge de résolutions plus élevées et des fonctionnalités supplémentaires.
Stable Diffusion XL (SDXL) (avril 2023) s'est concentrée sur le photoréalisme, cette version a introduit des améliorations de la composition d'image et de la génération de visage.
Stable Diffusion 3.0 (février 2024) avec une nouvelle architecture qui combine les transformateurs de diffusion et la correspondance de débit, cette version améliore les performances des requêtes multi-sujets et la qualité globale de l'image.
Stable Cascade (février 2024) construite sur l'architecture Würstchen, ce modèle améliore la précision et l'efficacité de la génération de texte à l'image.
Stable Diffusion 3.5 (octobre 2024) comprend des variantes telles que la diffusion stable 3,5 grand et 3,5 médium, offrant plus d'options pour diverses tâches de production avec une efficacité optimisée.
Important
Il s'agit d'une bibliothèque non officielle. Stabilité.ai ne fournit aucune bibliothèque officielle pour Delphi . Ce référentiel contient l'implémentation Delphi sur API publique stabilité.ai.
Vous pouvez accéder à la console stabilité.ai pour explorer les possibilités disponibles.
Pour obtenir une clé API, vous devez créer un compte. Un crédit de 25 vous sera accordé et une clé initiale sera automatiquement générée. Vous pouvez trouver cette clé ici.
Une fois que vous avez un jeton, vous pouvez initialiser l'interface IStabilityAI , qui est un point d'entrée à l'API.
Note
uses StabilityAI;
var Stability := TStabilityAIFactory.CreateInstance(API_KEY);Avertissement
Pour utiliser les exemples fournis dans ce tutoriel, en particulier pour travailler avec des méthodes asynchrones, je recommande de définir l'interface de stabilité avec la portée la plus large possible.
Donc, définissez Stability := TStabilityAIFactory.CreateInstance(API_KEY); dans l'événement OnCreate de votre demande.
Où Stability: IStabilityAI;
Dans le contexte des méthodes asynchrones, pour une méthode qui n'implique pas de streaming, les rappels utilisent l'enregistrement générique suivant: TAsynCallBack<T> = record défini dans l'unité StabilityAI.Async.Support.pas . Cet enregistrement expose les propriétés suivantes:
TAsynCallBack<T> = record
...
Sender: TObject;
OnStart: TProc<TObject>;
OnSuccess: TProc<TObject, T>;
OnError: TProc<TObject, string>; Le nom de chaque propriété est explicite; Si nécessaire, reportez-vous à la documentation interne pour plus de détails.
Note
Dans le reste du tutoriel, nous utiliserons principalement des méthodes anonymes, sauf indication contraire, car travailler avec les API l'exige en raison de délais de traitement qui peuvent parfois être assez longs.
Image stable ultra utilise le modèle Diffusion 3.5. Cette méthode est distinguée par:
Exemple de code asynchrone
// 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 );Paramètres détaillés sur la documentation officielle
Pour simplifier l'exemple de codes fournis dans ce tutoriel, j'ai inclus deux unités dans le code source: VCL.Stability.Tutorial et FMX.Stability.Tutorial . Selon l'option que vous choisissez de tester le code source fourni, vous devrez instancier la classe TVCLStabilitySender ou TFMXStabilitySender dans l'événement OnCreate de l'application, comme suit:
Conseil
// uses VCL.Stability.Tutorial;
StabilityResult := TVCLStabilitySender.Create(Memo1, Image1);ou
// uses FMX.Stability.Tutorial;
StabilityResult := TFMXStabilitySender.Create(Memo1, Image1); Assurez-vous d'ajouter un TMemo et un composant TImage à votre formulaire au préalable.
Il est également possible de fournir une image de référence à utiliser comme point de départ pour la génération. Dans ce cas, le paramètre strength doit être spécifié, car il détermine l'influence de l'image d'entrée sur la sortie finale. Une valeur strength de 0 produira une image identique à l'entrée, tandis qu'une valeur de 1 n'indique aucune influence de l'image initiale.
// 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 );Spécificité:
Stable Image Core est un service de génération de texte à l'image conçu pour offrir une qualité de qualité supérieure avec une vitesse. Contrairement à d'autres outils similaires, il ne nécessite aucune expertise en «ingénierie rapide». Les utilisateurs décrivent simplement un style, une scène ou un caractère, et l'outil génère une image qui s'aligne sur leur description.Points clés:
Inventaire des applications:
Exemple de code asynchrone
// 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 );Paramètres détaillés sur la documentation officielle
Vous pouvez guider le modèle d'image vers un style spécifique en sélectionnant parmi 17 styles disponibles.
// 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 );Inventaire des modèles disponibles
Diffusion stable 3.5
Diffusion stable 3.0 (feux d'artifice AI)
Points clés:
Turbo génèrent des images plus rapidement sans sacrifier la qualité. Ce mode crée une image basée uniquement sur une description textuelle. L' prompt est la seule entrée obligatoire, mais un paramètre aspect_ratio facultatif est disponible pour ajuster les dimensions de l'image résultante.
Exemple de code asynchrone
// 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 );Paramètres détaillés sur la documentation officielle
Cette méthode génère une image basée sur l'entrée de texte tout en utilisant une image existante comme référence initiale. Les paramètres nécessaires incluent:
prompt : le texte descriptif qui guide la génération d'images.image : L'image de départ qui sert de base à la sortie.strength : détermine le degré auquel l'image de départ influence le résultat final.mode : doit être défini sur "Image-Image".Exemple de code asynchrone
// 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
Remarque: La taille maximale de la demande est de 10mib.
Les deux modes permettent l'utilisation de ces paramètres facultatifs:
model : Spécifie le modèle à utiliser, tel que SD3 Large , SD3 Grand turbo ou milieu SD3 .output_format : détermine le format souhaité de l'image résultante.seed : Définit la graine aléatoire pour le processus de génération.negative_prompt : définit les mots clés pour exclure de l'image générée.cfg_scale : Ajuste le niveau d'adhésion au texte rapide pendant le processus de diffusion. Utilisation de SDXL 1.0: Utilisez stable-diffusion-xl-1024-v1-0 comme engine_id pour votre demande, et spécifiez les dimensions ( height et width ) avec l'une des combinaisons suivantes:
L'utilisation de SD 1.6 : SD 1.6 est un modèle de base de résolution flexible conçu pour générer des images avec des rapports d'aspect non standard. Le modèle est optimisé pour une résolution de 512 x 512 pixels. Pour créer des sorties avec une résolution de 1 mégapixel, nous vous recommandons d'utiliser SDXL 1.0, qui est disponible au même prix.
Pour utiliser ce modèle, définissez stable-diffusion-v1-6 comme engine_id dans votre demande et assurez-vous que la height et width répondent aux exigences suivantes:
Exemple de code asynchrone
// 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 );Paramètres détaillés sur la documentation officielle
Ajuster le degré de transformation
init_image_mode=IMAGE_STRENGTH avec image_strength=0.35 , ou utiliser init_image_mode=STEP_SCHEDULE avec step_schedule_start=0.65 . Les deux méthodes donnent des résultats similaires, mais le mode step_schedule offre une flexibilité supplémentaire en vous permettant de spécifier une valeur step_schedule_end , donnant un contrôle plus nuancé si nécessaire. Pour plus de détails, reportez-vous aux descriptions de paramètres spécifiques ci-dessous.Exemple de code asynchrone
// 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 );Conseil
Dans notre exemple de code, la valeur du paramètre des échantillons est 3, ce qui signifie que trois images ont été générées. Seul le premier est affiché. Les deux autres ont été enregistrés avec des noms de fichiers indexés comme suit: Lighthouse701.png et Lighthouse702.png.
Paramètres détaillés sur la documentation officielle
Modifiez des parties spécifiques d'une image à l'aide d'un masque. Le masque doit correspondre aux dimensions et à la forme de l'image d'origine. Cette fonctionnalité prend également en charge les images avec des canaux alpha.
Utilisez la métode:
ImageToImageWithMask( const Model: string; ParamProc: TProc<TPayloadMask>;
CallBacks: TFunc<TAsynArtifacts>);Outils pour améliorer la taille et la résolution de vos images
Haut-parleur conservatrice
UpScaleur créatif
UpScaleur rapide
Accepte des images allant de 64x64 pixels jusqu'à 1 mégapixel et améliore leur résolution à 4k. Plus largement, il peut augmenter les images d'environ 20 à 40 fois tout en conservant leurs détails d'origine. L'option conservatrice haut de gamme se concentre sur la préservation de l'intégrité de l'image avec des modifications minimales et n'est pas destinée à réinterpréter le contenu de l'image.
Exemple de code asynchrone
// 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 );Paramètres détaillés sur la documentation officielle
Accepte des images allant de 64x64 pixels à un maximum de 1 mégapixel, améliorant leur résolution jusqu'à 4k. Plus largement, il peut augmenter les images d'environ 20 à 40 fois tout en maintenant - et souvent en amélioration - leur qualité. La fonction créative haut de gamme est particulièrement efficace pour les images fortement dégradées, mais elle n'est pas adaptée aux photos supérieures à 1 mégapixel, car elle applique une réinterprétation significative (réglable via l'échelle de créativité).
Avertissement
Cette fonction est étiquetée comme asynchrone par l'éditeur, mais en réalité, il ne se comporte pas comme tel pour une application tierce en utilisant. Il fonctionne plus comme un mécanisme de mise en cache pour un traitement légèrement retardé.
Exemple de code asynchrone
// 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 );Paramètres détaillés sur la documentation officielle
Nous récupérons l'ID du travail, et à l'étape suivante, nous devons charger l'image à moins que l'état récupéré ne soit «en cours». Dans ce cas, l'opération doit être réactivée.
// 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 );Paramètres détaillés sur la documentation officielle
Le service rapide de l'immeublement en résolution d'image de 400%. Conçu pour la vitesse et l'efficacité, il traite des images en environ une seconde, ce qui en fait un excellent outil pour améliorer la clarté des visuels compressés, parfaits pour les publications de médias sociaux et diverses autres utilisations.
Exemple de code asynchrone
// 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 );Paramètres détaillés sur la documentation officielle
Inventaire des fonctionnalités
Le service d'effacement est conçu pour éliminer les éléments indésirables des images, telles que les imperfections sur les faces ou les objets sur les surfaces, en utilisant des techniques de masquage.
Masks peuvent être fournis dans l'une des deux méthodes:
mask .Exemple de code asynchrone
Note
mask spécifique n'est fourni, un masque sera automatiquement généré en fonction du canal alpha de l'image. Les zones transparentes seront soumises à l'instruction, tandis que les régions opaques resteront inchangées.mask , le mask remplacera le canal alpha. // 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 );Lorsqu'un masque est fourni:
Note
mask diffèrent de celles du paramètre d'image, il sera automatiquement ajusté pour correspondre à la taille de l'image. Stability.StableImage.Edit.Erase(
procedure (Params: TErase)
begin
Params.Image( ' Lighthouse.png ' );
Params.Mask( ' MyMask01.png ' );
Params.GrowMask( 6 );
Params.OutputFormat(png);
end ,
...Paramètres détaillés sur la documentation officielle
Modifiez les images intelligemment en ajoutant ou en remplaçant des sections spécifiques par de nouveaux contenus, guidés par une image mask .
Ce mask peut être fourni de deux manières:
// 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 ); L'utilisation du mask est identique à celle décrite avec l'API Efface.
Paramètres détaillés sur la documentation officielle
Le service ORPAINT permet l'extension transparente d'une image en ajoutant du contenu dans n'importe quelle direction pour remplir l'espace environnant. Contrairement à d'autres méthodes, qu'elles soient automatisées ou manuelles, ce service est conçu pour réduire les artefacts visibles et éviter les indications notables de l'édition d'images.
// 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 );Paramètres détaillés sur la documentation officielle
Le service de recherche et de remplacement offre une forme spécialisée d'intervention qui élimine le besoin d'un masque. Au lieu de cela, les utilisateurs peuvent spécifier un objet à remplacer en le décrivant en langage clair à l'aide d'un Search_Prompt. Le service détectera et segmentera ensuite automatiquement l'objet spécifié, le substituant de manière transparente par celui décrit dans l'invite.
// 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 );Paramètres détaillés sur la documentation officielle
En utilisant le service de recherche et de recolor, vous pouvez modifier la couleur d'un objet spécifique dans une image via une simple invite. Cette forme spécialisée d'instruction ne nécessite pas de masque. Au lieu de cela, le service segmente automatiquement l'objet et applique les nouvelles couleurs spécifiées dans votre invite.
// 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 );Paramètres détaillés sur la documentation officielle
Le service d'arrière-plan de suppression identifie et isole précisément le premier plan dans une image, permettant à l'arrière-plan d'être supprimé ou remplacé au besoin.
// 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 );Paramètres détaillés sur la documentation officielle
Le service Remplacer l'arrière-plan et l'édition de relâche permet de modifier sans effort des arrière-plans à l'aide d'images générées par l'IA ou de leurs propres téléchargements, tout en ajustant de manière transparente l'éclairage pour compléter le sujet. Cette API propose une solution de montage d'image efficace adaptée à diverses industries, notamment le commerce électronique, l'immobilier, la photographie et les efforts créatifs.
Les caractéristiques clés comprennent:
Avertissement
Cette fonction est étiquetée comme asynchrone par l'éditeur, mais en réalité, il ne se comporte pas comme tel pour une application tierce en utilisant. Il fonctionne plus comme un mécanisme de mise en cache pour un traitement légèrement retardé.
// 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 );L'API renvoie l'ID de la tâche en cours, tout comme l'API créatif haut de gamme. Vous devez ensuite utiliser l'API Fetch, comme mentionné précédemment.
Paramètres détaillés sur la documentation officielle
Outils pour créer des variations contrôlées d'images et de croquis
Cet outil est conçu pour les flux de travail de développement impliquant une conception itérative et un brainstorming. Il transforme les croquis dessinés à la main en visuels polis avec des ajustements précis. De plus, il permet un contrôle affiné sur l'apparence finale des images non sketch en utilisant les contours et les bords de l'image.
// 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 );Paramètres détaillés sur la documentation officielle
Ce service est conçu pour générer des images tout en préservant la structure d'une image d'entrée, ce qui le rend particulièrement utile pour des tâches telles que la réplication des scènes ou des caractères de rendu basés sur des modèles prédéfinis.
// 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 );Paramètres détaillés sur la documentation officielle
Cet outil analyse les caractéristiques stylistiques d'une image d'entrée donnée (image de contrôle) et les applique pour générer une nouvelle image guidée par une invite spécifiée. L'image de sortie conserve le style visuel de l'image de contrôle tout en incorporant le contenu demandé.
// 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 );Paramètres détaillés sur la documentation officielle
Outils pour récupérer les résultats de vos générations asynchrones.
Pour l'utilisation, voir Fetch Async Generation Result
STABLE FAST 3D génère des actifs 3D de haute qualité à partir d'une seule image d'entrée 2D.
Voir la spécification du format de fichier GLB pour plus de détails.
// 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 );Paramètres détaillés sur la documentation officielle
Utilisez une diffusion vidéo stable , un modèle de diffusion vidéo latente, pour générer une courte vidéo à partir d'une image initiale.
ID à partir de la réponse pour vérifier les résultats au point de terminaison image-to-video/result/{id} . Assurez-vous de ne pas interroger ce point final plus d'une fois toutes les 10 secondes pour éviter les erreurs ou les problèmes de limitation des taux. // 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 );À la fin, nous récupérons l'ID ( par exemple D4FB4AA8301AEE0B368A41B3C0A78018DFC28F1F959A3666BE2E6951408FB8E3 ) de la tâche de création vidéo. Ensuite, nous récupérons simplement le résultat de cette manière.
Paramètres détaillés sur la documentation officielle
// 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 );Paramètres détaillés sur la documentation officielle
Énumérez les moteurs compatibles avec les points de terminaison de l'API REST Version 1 .
// 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 );Paramètres détaillés sur la documentation officielle
Récupérer des détails sur le compte lié à la clé API spécifiée
// 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 );Paramètres détaillés sur la documentation officielle
Récupérez le solde de crédit pour le compte ou l'organisation liée à la clé API fournie.
// 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 ;Paramètres détaillés sur la documentation officielle
Stabilité.ai a annoncé deux fonctionnalités à venir:
Stable LLM 12B et Stable LLM 1.6B .Audio Stable 2.0 . Vous pouvez contacter Stability.ai pour tester ce modèle en envoyant un message.Les demandes de traction sont les bienvenues. Si vous prévoyez d'apporter un changement majeur, veuillez d'abord ouvrir un problème pour discuter de vos modifications proposées.
Ce projet est autorisé sous la licence du MIT.
