Générer des images

L'API Gemini prend en charge la génération d'images à l'aide de Gemini 2.0 Flash Experimental et de Imagen 3. Ce guide vous aidera à vous lancer avec les deux modèles.

Pour obtenir des conseils sur les requêtes d'image, consultez la section Guide de requête Imagen.

Avant de commencer

Avant d'appeler l'API Gemini, assurez-vous d'avoir installé le SDK de votre choix et d'avoir configuré une clé API Gemini prête à l'emploi.

Générer des images à l'aide de Gemini

Gemini 2.0 Flash Experimental permet de générer du texte et des images intégrées. Vous pouvez ainsi utiliser Gemini pour modifier des images de manière conversationnelle ou générer des sorties avec du texte entrelacé (par exemple, générer un article de blog avec du texte et des images en une seule phrase). Toutes les images générées incluent un filigrane SynthID, et les images de Google AI Studio incluent également un filigrane visible.

L'exemple suivant montre comment utiliser Gemini 2.0 pour générer une sortie texte et image:

from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO
import base64

client = genai.Client()

contents = ('Hi, can you create a 3d rendered image of a pig '
            'with wings and a top hat flying over a happy '
            'futuristic scifi city with lots of greenery?')

response = client.models.generate_content(
    model="gemini-2.0-flash-exp-image-generation",
    contents=contents,
    config=types.GenerateContentConfig(
      response_modalities=['TEXT', 'IMAGE']
    )
)

for part in response.candidates[0].content.parts:
  if part.text is not None:
    print(part.text)
  elif part.inline_data is not None:
    image = Image.open(BytesIO((part.inline_data.data)))
    image.save('gemini-native-image.png')
    image.show()

import { GoogleGenAI, Modality } from "@google/genai";
import * as fs from "node:fs";

async function main() {

  const ai = new GoogleGenAI({ apiKey: "GEMINI_API_KEY" });

  const contents =
    "Hi, can you create a 3d rendered image of a pig " +
    "with wings and a top hat flying over a happy " +
    "futuristic scifi city with lots of greenery?";

  // Set responseModalities to include "Image" so the model can generate  an image
  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash-exp-image-generation",
    contents: contents,
    config: {
      responseModalities: [Modality.TEXT, Modality.IMAGE],
    },
  });
  for (const part of response.candidates[0].content.parts) {
    // Based on the part type, either show the text or save the image
    if (part.text) {
      console.log(part.text);
    } else if (part.inlineData) {
      const imageData = part.inlineData.data;
      const buffer = Buffer.from(imageData, "base64");
      fs.writeFileSync("gemini-native-image.png", buffer);
      console.log("Image saved as gemini-native-image.png");
    }
  }
}

main();

package main

import (
  "context"
  "fmt"
  "os"
  "google.golang.org/genai"
)

func main() {

  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
      APIKey:  os.Getenv("GEMINI_API_KEY"),
      Backend: genai.BackendGeminiAPI,
  })

  config := &genai.GenerateContentConfig{
      ResponseModalities: []string{"TEXT", "IMAGE"},
  }

  result, _ := client.Models.GenerateContent(
      ctx,
      "gemini-2.0-flash-exp-image-generation",
      genai.Text("Hi, can you create a 3d rendered image of a pig " +
                 "with wings and a top hat flying over a happy " +
                 "futuristic scifi city with lots of greenery?"),
      config,
  )

  for _, part := range result.Candidates[0].Content.Parts {
      if part.Text != "" {
          fmt.Println(part.Text)
      } else if part.InlineData != nil {
          imageBytes := part.InlineData.Data
          outputFilename := "gemini_generated_image.png"
          _ = os.WriteFile(outputFilename, imageBytes, 0644)
      }
  }
}

curl -s -X POST \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp-image-generation:generateContent?key=$GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [
        {"text": "Hi, can you create a 3d rendered image of a pig with wings and a top hat flying over a happy futuristic scifi city with lots of greenery?"}
      ]
    }],
    "generationConfig":{"responseModalities":["TEXT","IMAGE"]}
  }' \
  | grep -o '"data": "[^"]*"' \
  | cut -d'"' -f4 \
  | base64 --decode > gemini-native-image.png

En fonction de la requête et du contexte, Gemini génère du contenu dans différents modes (texte vers image, texte vers image et texte, etc.). Voici quelques exemples :

• Texte vers image
  • Exemple de requête : "Génère une image de la tour Eiffel avec des feux d'artifice en arrière-plan."
• Texte vers une ou plusieurs images et texte (entrelacé)
  • Exemple de requête : "Génère une recette illustrée pour une paella."
• Image(s) et texte vers image(s) et texte (entrelacé)
  • Exemple de requête : (avec une image d'une pièce meublée) "Quelle autre couleur de canapé irait bien dans mon espace ? Pouvez-vous mettre à jour l'image ?"
• Modification d'images (texte et image vers image)
  • Exemple de requête : "Modifiez cette image pour qu'elle ressemble à un dessin animé"
  • Exemple de requête : [image d'un chat] + [image d'un oreiller] + "Crée un point de croix de mon chat sur cet oreiller."
• Modification d'images multitours (chat)
  • Exemples de requêtes : [importez une image d'une voiture bleue.] "Transformez cette voiture en cabriolet." "Maintenant, changez la couleur en jaune."

Modifier des images avec Gemini

Pour effectuer une modification d'image, ajoutez une image en entrée. L'exemple suivant montre comment importer des images encodées en base64. Pour plusieurs images et des charges utiles plus importantes, consultez la section Entrée d'image.

from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO

import PIL.Image

image = PIL.Image.open('/path/to/image.png')

client = genai.Client()

text_input = ('Hi, This is a picture of me.'
            'Can you add a llama next to me?',)

response = client.models.generate_content(
    model="gemini-2.0-flash-exp-image-generation",
    contents=[text_input, image],
    config=types.GenerateContentConfig(
      response_modalities=['TEXT', 'IMAGE']
    )
)

for part in response.candidates[0].content.parts:
  if part.text is not None:
    print(part.text)
  elif part.inline_data is not None:
    image = Image.open(BytesIO(part.inline_data.data))
    image.show()

import { GoogleGenAI, Modality } from "@google/genai";
import * as fs from "node:fs";

async function main() {

  const ai = new GoogleGenAI({ apiKey: "GEMINI_API_KEY" });

  // Load the image from the local file system
  const imagePath = "path/to/image.png";
  const imageData = fs.readFileSync(imagePath);
  const base64Image = imageData.toString("base64");

  // Prepare the content parts
  const contents = [
    { text: "Can you add a llama next to the image?" },
    {
      inlineData: {
        mimeType: "image/png",
        data: base64Image,
      },
    },
  ];

  // Set responseModalities to include "Image" so the model can generate an image
  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash-exp-image-generation",
    contents: contents,
    config: {
      responseModalities: [Modality.TEXT, Modality.IMAGE],
    },
  });
  for (const part of response.candidates[0].content.parts) {
    // Based on the part type, either show the text or save the image
    if (part.text) {
      console.log(part.text);
    } else if (part.inlineData) {
      const imageData = part.inlineData.data;
      const buffer = Buffer.from(imageData, "base64");
      fs.writeFileSync("gemini-native-image.png", buffer);
      console.log("Image saved as gemini-native-image.png");
    }
  }
}

main();

package main

import (
 "context"
 "fmt"
 "os"
 "google.golang.org/genai"
)

func main() {

 ctx := context.Background()
 client, _ := genai.NewClient(ctx, &genai.ClientConfig{
     APIKey:  os.Getenv("GEMINI_API_KEY"),
     Backend: genai.BackendGeminiAPI,
 })

 imagePath := "/path/to/image.png"
 imgData, _ := os.ReadFile(imagePath)

 parts := []*genai.Part{
   genai.NewPartFromText("Hi, This is a picture of me. Can you add a llama next to me?"),
   &genai.Part{
     InlineData: &genai.Blob{
       MIMEType: "image/png",
       Data:     imgData,
     },
   },
 }

 contents := []*genai.Content{
   genai.NewContentFromParts(parts, genai.RoleUser),
 }

 config := &genai.GenerateContentConfig{
     ResponseModalities: []string{"TEXT", "IMAGE"},
 }

 result, _ := client.Models.GenerateContent(
     ctx,
     "gemini-2.0-flash-exp-image-generation",
     contents,
     config,
 )

 for _, part := range result.Candidates[0].Content.Parts {
     if part.Text != "" {
         fmt.Println(part.Text)
     } else if part.InlineData != nil {
         imageBytes := part.InlineData.Data
         outputFilename := "gemini_generated_image.png"
         _ = os.WriteFile(outputFilename, imageBytes, 0644)
     }
 }
}

IMG_PATH=/path/to/your/image1.jpeg

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

IMG_BASE64=$(base64 "$B64FLAGS" "$IMG_PATH" 2>&1)

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp-image-generation:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -d "{
      \"contents\": [{
        \"parts\":[
            {\"text\": \"'Hi, This is a picture of me. Can you add a llama next to me\"},
            {
              \"inline_data\": {
                \"mime_type\":\"image/jpeg\",
                \"data\": \"$IMG_BASE64\"
              }
            }
        ]
      }],
      \"generationConfig\": {\"responseModalities\": [\"TEXT\", \"IMAGE\"]}
    }"  \
  | grep -o '"data": "[^"]*"' \
  | cut -d'"' -f4 \
  | base64 --decode > gemini-edited-image.png

Limites

• Pour des performances optimales, utilisez les langues suivantes: EN, es-MX, ja-JP, zh-CN et hi-IN.
• La génération d'images n'est pas compatible avec les entrées audio ni vidéo.
• La génération d'images ne se déclenche pas toujours :
  • Le modèle peut ne générer que du texte. Essayez de demander explicitement des sorties d'image (par exemple, "générer une image", "fournir des images au fur et à mesure", "mettre à jour l'image").
  • Le modèle peut s'arrêter en cours de génération. Réessayez ou utilisez une autre requête.
• Lorsque vous générez du texte pour une image, Gemini fonctionne mieux si vous générez d'abord le texte, puis demandez une image avec le texte.

Choisir un modèle

Quel modèle devez-vous utiliser pour générer des images ? Cela dépend de votre cas d'utilisation.

Gemini 2.0 est idéal pour produire des images contextuellement pertinentes, mélanger du texte et des images, intégrer des connaissances du monde et raisonner sur les images. Vous pouvez l'utiliser pour créer des visuels précis et pertinents dans le contexte, intégrés à de longues séquences de texte. Vous pouvez également modifier des images de manière conversationnelle, en utilisant un langage naturel, tout en conservant le contexte tout au long de la conversation.

Si la qualité de l'image est votre priorité absolue, Imagen 3 est la meilleure option. Imagen 3 excelle dans le photoréalisme, les détails artistiques et les styles artistiques spécifiques tels que l'impressionnisme ou l'anime. Imagen 3 est également un bon choix pour les tâches de retouche d'images spécialisées, comme la mise à jour des arrière-plans de produits, l'amélioration de la résolution des images et l'intégration de branding et de style dans les visuels. Vous pouvez utiliser Imagen 3 pour créer des logos ou d'autres conceptions de produits de marque.

Générer des images à l'aide d'Imagen 3

L'API Gemini donne accès à Imagen 3, le modèle texte-vers-image de Google de la plus haute qualité, qui offre un certain nombre de nouvelles fonctionnalités améliorées. Voici ce que vous pouvez faire avec Imagen 3:

• Générer des images avec des détails plus précis, un éclairage plus riche et moins d'artefacts gênants que les modèles précédents
• Comprendre les requêtes rédigées en langage naturel
• Générer des images dans un large éventail de formats et de styles
• Afficher le texte plus efficacement que les modèles précédents

from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO

client = genai.Client(api_key='GEMINI_API_KEY')

response = client.models.generate_images(
    model='imagen-3.0-generate-002',
    prompt='Robot holding a red skateboard',
    config=types.GenerateImagesConfig(
        number_of_images= 4,
    )
)
for generated_image in response.generated_images:
  image = Image.open(BytesIO(generated_image.image.image_bytes))
  image.show()

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

async function main() {

  const ai = new GoogleGenAI({ apiKey: "GEMINI_API_KEY" });

  const response = await ai.models.generateImages({
    model: 'imagen-3.0-generate-002',
    prompt: 'Robot holding a red skateboard',
    config: {
      numberOfImages: 4,
    },
  });

  let idx = 1;
  for (const generatedImage of response.generatedImages) {
    let imgBytes = generatedImage.image.imageBytes;
    const buffer = Buffer.from(imgBytes, "base64");
    fs.writeFileSync(`imagen-${idx}.png`, buffer);
    idx++;
  }
}

main();

package main

import (
  "context"
  "fmt"
  "os"
  "google.golang.org/genai"
)

func main() {

  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
      APIKey:  os.Getenv("GEMINI_API_KEY"),
      Backend: genai.BackendGeminiAPI,
  })

  config := &genai.GenerateImagesConfig{
      NumberOfImages: 4,
  }

  response, _ := client.Models.GenerateImages(
      ctx,
      "imagen-3.0-generate-002",
      "Robot holding a red skateboard",
      config,
  )

  for n, image := range response.GeneratedImages {
      fname := fmt.Sprintf("imagen-%d.png", n)
          _ = os.WriteFile(fname, image.Image.ImageBytes, 0644)
  }
}

curl -X POST \
    "https://generativelanguage.googleapis.com/v1beta/models/imagen-3.0-generate-002:predict?key=GEMINI_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
        "instances": [
          {
            "prompt": "Robot holding a red skateboard"
          }
        ],
        "parameters": {
          "sampleCount": 4
        }
      }'

Pour le moment, Imagen n'accepte que les requêtes en anglais et les paramètres suivants:

Paramètres du modèle Imagen

Les conventions de nommage varient en fonction du langage de programmation.

• numberOfImages: nombre d'images à générer, compris entre 1 et 4 (inclus). La valeur par défaut est 4.
• aspectRatio: modifie le format de l'image générée. Les valeurs acceptées sont "1:1", "3:4", "4:3", "9:16" et "16:9". La valeur par défaut est "1:1".
• personGeneration: autoriser le modèle à générer des images de personnes. Les valeurs suivantes sont acceptées :
  • "DONT_ALLOW": bloquer la génération d'images de personnes.
  • "ALLOW_ADULT": générer des images d'adultes, mais pas d'enfants Ce paramètre est la valeur par défaut.

Guide de requête Imagen

Cette section du guide Imagen vous montre comment modifier une requête texte-image peut produire différents résultats, ainsi que des exemples d'images que vous pouvez créer.

Principes de base concernant l'écriture de requêtes

Une invite efficace est descriptive et claire, et utilise des mots clés et des modificateurs pertinents. Commencez par réfléchir à votre sujet, au contexte et au style.

1. Objet : La première chose à laquelle réfléchir pour une requête est l'objet : c'est-à-dire l'objet, la personne, l'animal ou le paysage dont vous souhaitez obtenir une image.

2. Contexte et arrière-plan : L'arrière-plan ou le contexte dans lequel le sujet sera placé est tout aussi important. Essayez de placer votre sujet dans différents arrière-plans. Par exemple, un studio sur fond blanc, en extérieur ou en intérieur.

3. Style : Pour finir, ajoutez le style d'image souhaité. Les styles peuvent être généraux (peinture, photographie, croquis) ou très spécifiques (pastel, fusain, 3D isométrique). Vous pouvez également combiner des styles.

Après avoir rédigé une première version de votre requête, affinez-la en ajoutant plus de détails jusqu'à obtenir l'image souhaitée. L'itération est importante. Commencez par définir votre idée de base, puis affinez-la et développez-la jusqu'à ce que l'image générée soit proche de votre vision.

Imagen 3 peut transformer vos idées en images détaillées, que vos requêtes soient courtes ou longues et détaillées. Affinez votre vision grâce à des invites itératives, en ajoutant des détails jusqu'à obtenir le résultat parfait.

Les requêtes courtes vous permettent de générer une image rapidement.

Les requêtes plus longues vous permettent d'ajouter des détails spécifiques et de créer votre image.

Conseils supplémentaires pour rédiger des requêtes Imagen:

• Utilisez un langage descriptif: utilisez des adjectifs et des adverbes détaillés pour donner une image claire de l'image 3.
• Fournissez du contexte: si nécessaire, incluez des informations générales pour aider l'IA à comprendre.
• Référez-vous à des artistes ou des styles spécifiques: si vous avez une esthétique particulière en tête, il peut être utile de vous référer à des artistes ou des mouvements artistiques spécifiques.
• Utilisez des outils d'ingénierie des requêtes: envisagez d'explorer des outils ou des ressources d'ingénierie des requêtes pour vous aider à affiner vos requêtes et à obtenir des résultats optimaux.
• Améliorer les détails du visage dans vos images personnelles et de groupe :
  • Spécifiez les détails du visage comme sujet de la photo (par exemple, utilisez le mot "portrait" dans la requête).

Générer du texte dans des images

Imagen peut ajouter du texte aux images, ce qui ouvre de nouvelles possibilités de génération d'images créatives. Suivez les conseils suivants pour exploiter tout le potentiel de cette fonctionnalité:

• Itérer en toute confiance: vous devrez peut-être générer à nouveau des images jusqu'à obtenir l'apparence souhaitée. L'intégration du texte dans Imagen est encore en cours d'évolution, et parfois plusieurs tentatives permettent d'obtenir les meilleurs résultats.
• Soyez concis: limitez le texte à 25 caractères maximum pour une génération optimale.

• Plusieurs termes: testez deux ou trois expressions distinctes pour fournir des informations supplémentaires. Évitez de dépasser trois expressions pour des compositions plus claires.

  

• Guide de positionnement: même si Imagen peut essayer de positionner le texte comme indiqué, des variations peuvent se produire de temps en temps. Cette fonctionnalité est en constante amélioration.

• Inspire font style (Inspirer un style de police) : spécifiez un style de police général pour influencer subtilement les choix d'Imagen. Ne vous appuyez pas sur une réplication précise des polices, mais attendez-vous à des interprétations créatives.

• Taille de la police: spécifiez une taille de police ou une indication générale de taille (par exemple, petite, moyenne, grande) pour influencer la génération de la taille de police.

Paramétrage des requêtes

Pour mieux contrôler les résultats de sortie, vous pouvez trouver utile de paramétrer les entrées dans Imagen. Par exemple, supposons que vous souhaitiez que vos clients puissent générer des logos pour leur entreprise et que vous souhaitiez vous assurer qu'ils sont toujours générés sur un arrière-plan de couleur unie. Vous souhaitez également limiter les options que le client peut sélectionner dans un menu.

Dans cet exemple, vous pouvez créer une requête paramétrée semblable à celle-ci:

A {logo_style} logo for a {company_area} company on a solid color background. Include the text {company_name}.

Dans votre interface utilisateur personnalisée, le client peut saisir les paramètres à l'aide d'un menu, et la valeur choisie est renseignée dans l'invite reçue par Imagen.

Exemple :

1. Invite : A minimalist logo for a health care company on a solid color background. Include the text Journey.

   

2. Invite : A modern logo for a software company on a solid color background. Include the text Silo.

   

3. Invite : A traditional logo for a baking company on a solid color background. Include the text Seed.

   

Techniques d'écriture de requête avancées

Utilisez les exemples suivants pour créer des requêtes plus spécifiques basées sur des attributs tels que les descripteurs de photo, les formes et les matériaux, les courants artistiques historiques et les modificateurs de qualité d'image.

Photographie

• La requête inclut : "Une photo de…"

Pour utiliser ce style, commencez par utiliser des mots clés qui indiquent clairement à Imagen que vous recherchez une photographie. Start your prompts with "A photo of. . .". Par exemple :

^{Source de l'image: chaque image a été générée à l'aide de la requête textuelle correspondante avec le modèle Imagen 3.}

Modificateurs de photo

Dans les exemples suivants, vous pouvez voir plusieurs modificateurs et paramètres spécifiques à la photographie. Vous pouvez combiner plusieurs modificateurs pour un contrôle plus précis.

1. Proximité de l'appareil : gros plan, plan large

2. Position de l'appareil : vue aérienne, vue de dessous

3. Éclairage : naturel, spectaculaire, chaud, froid

4. Paramètres de l'appareil : flou de mouvement, flou artistique, bokeh, portrait

5. Types d'objectifs : 35 mm, 50 mm, fisheye, grand angle, macro

6. Types de pellicule : noir et blanc, polaroid

^{Source de l'image: chaque image a été générée à l'aide de la requête textuelle correspondante avec le modèle Imagen 3.}

Illustration et art

• La requête inclut : "Une painting de…", "Une sketch de…"

Les styles artistiques vont des styles monochromes tels que les esquisses au crayon à l'art numérique hyperréaliste. Par exemple, les images suivantes utilisent la même requête avec différents styles :

"Une [art style or creation technique] d'une berline électrique angulaire avec des gratte-ciel en arrière-plan"

^{Source de l'image: chaque image a été générée à l'aide de la requête textuelle correspondante avec le modèle Imagen 2.}

Formes et matériaux

• La requête inclut : "…fait en…", "…en forme de…"

L'un des points forts de cette technologie est que vous pouvez créer des images qui seraient autrement difficiles voire impossibles à obtenir. Par exemple, vous pouvez recréer le logo de votre entreprise dans différents matériaux et textures.

^{Source de l'image: chaque image a été générée à l'aide de la requête textuelle correspondante avec le modèle Imagen 3.}

Références artistiques historiques

• La requête inclut : "…dans le style de…"

Certains styles sont devenus iconiques au fil des années. Voici quelques idées de styles artistiques ou de peinture que vous pouvez essayer.

"Générer une image dans le style de [art period or movement] : une ferme éolienne"

^{Source de l'image: chaque image a été générée à l'aide de la requête textuelle correspondante avec le modèle Imagen 3.}

Modificateurs de qualité d'image

Certains mots clés peuvent indiquer au modèle que vous recherchez un élément de haute qualité. Voici quelques exemples de modificateurs de qualité :

• Modificateurs généraux : de haute qualité, agréable, stylisé
• Photos : 4K, HDR, photo studio
• Art, iIlustration : professionnel, détaillé

Voici quelques exemples de requêtes utilisées avec et sans modificateurs de qualité.

^{Source de l'image: chaque image a été générée à l'aide de la requête textuelle correspondante avec le modèle Imagen 3.}

Formats

La génération d'images Imagen 3 vous permet de définir cinq formats d'image distincts.

1. Carré (1:1, par défaut) : photo carrée standard. Les utilisations courantes de ce format incluent les publications sur les réseaux sociaux.

2. Plein écran (4:3) : ce format est couramment utilisé dans les médias ou les films. Il correspond également aux dimensions de la plupart des anciens téléviseurs (non panoramiques) et des appareils photo de format moyen. Il capture une plus grande partie de la scène horizontalement (comparé au format 1:1), ce qui en fait le format préféré pour la photographie.

3. Portrait plein écran (3:4) : il s'agit du format plein écran ayant une rotation de 90 degrés. Cela permet de capturer une plus grande partie de la scène verticalement par rapport au format 1:1.

4. Écran large (16:9) : ce format a remplacé le format 4:3 et est désormais le format le plus courant pour les téléviseurs, les écrans d'ordinateur et les écrans de téléphones mobiles (paysage). Utilisez ce format lorsque vous souhaitez capturer davantage d'arrière-plan (par exemple, des paysages).

   

5. Portrait (9:16) : il s'agit d'un format grand écran, mais pivoté. Il s'agit d'un format relativement nouveau qui est rendu populaire par les applications vidéo courtes (par exemple, les Shorts YouTube). Utilisez ce format pour les éléments élevés ayant une orientation verticale marquée, tels que les bâtiments, les arbres, les cascades ou d'autres éléments similaires.

   

Images photoréalistes

Différentes versions du modèle de génération d'images peuvent offrir une combinaison de sorties artistiques et photoréalistes. Utilisez les mots suivants dans vos requêtes pour générer un résultat plus réaliste en fonction du sujet que vous souhaitez générer.

Portraits

Avec plusieurs mots clés du tableau, Imagen peut générer les portraits suivants:

Requête: Femme, portrait en 35 mm, bichromie bleu et gris
Modèle: imagen-3.0-generate-002

Requête: Femme, portrait en 35 mm, film noir
Modèle: imagen-3.0-generate-002

Objets

Avec plusieurs mots clés du tableau, Imagen peut générer les images d'objets suivantes:

Requête: feuille de maranta, objectif macro, 60 mm
Modèle: imagen-3.0-generate-002

Requête: Assiette de pâtes, Objectif macro de 100 mm
Modèle: imagen-3.0-generate-002

Mouvement

Avec plusieurs mots clés du tableau, Imagen peut générer les images de mouvement suivantes:

Requête: Un "touchdown" victorieux, vitesse d'obturation rapide, suivi des mouvements
Modèle: imagen-3.0-generate-002

Requête: Cerf courant dans la forêt, vitesse d'obturation rapide, suivi des mouvements
Modèle: imagen-3.0-generate-002

Grand angle

Avec plusieurs mots clés du tableau, Imagen peut générer les images grand angle suivantes:

Requête: Une chaîne de montagnes très large, paysage grand angle de 10 mm
Modèle: imagen-3.0-generate-002

Requête: une photo de la lune, astrophotographie, grand angle de 10 mm
Modèle: imagen-3.0-generate-002

Étape suivante

• Consultez le guide Veo pour découvrir comment générer des vidéos avec l'API Gemini.
• Pour en savoir plus sur les modèles Gemini 2.0, consultez les pages Modèles Gemini et Modèles expérimentaux.