Generowanie obrazów

Obrazy możesz generować za pomocą interfejsu Gemini API z wykorzystaniem wbudowanych funkcji multimodalnych Gemini lub modelu Imagen, czyli wyspecjalizowanego modelu generowania obrazów od Google. W większości przypadków zacznij od Gemini. Wybierz Imagen do specjalistycznych zadań, w których przypadku jakość obrazu ma kluczowe znaczenie. Więcej wskazówek znajdziesz w sekcji Wybieranie odpowiedniego modelu.

Wszystkie wygenerowane obrazy zawierają znak wodny SynthID.

Zanim zaczniesz

Upewnij się, że do generowania obrazów używasz obsługiwanego modelu i wersji:

• W przypadku Gemini użyj funkcji generowania obrazów do podglądu Gemini 2.0 Flash.

• W przypadku Imagen użyj jednego z modeli Imagen (Imagen 3, Imagen 4 lub Imagen 4 Ultra).

  • Pamiętaj, że te modele są dostępne tylko w płatnej wersji.

Możesz uzyskać dostęp do modeli Gemini i Imagen, korzystając z tych samych bibliotek.

Generowanie obrazów za pomocą Gemini

Gemini może generować i przetwarzać obrazy w ramach konwersacji. Aby wykonywać różne zadania związane z obrazami, takie jak generowanie i edytowanie obrazów, możesz promptować Gemini za pomocą tekstu, obrazów lub ich kombinacji.

W konfiguracji musisz uwzględnić responseModalities: ["TEXT", "IMAGE"]. Te modele nie obsługują danych wyjściowych w postaci tylko obrazu.

generowanie obrazów (tekst na obraz);

Poniższy kod pokazuje, jak wygenerować obraz na podstawie promptu opisowego:

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-preview-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-preview-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-preview-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-preview-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

Edytowanie obrazów (tekst i przekształcanie obrazu)

Aby edytować obraz, dodaj obraz jako dane wejściowe. W tym przykładzie pokazano przesyłanie obrazów zakodowanych w formacie base64. Więcej informacji o przesyłaniu wielu obrazów i większych zasobów danych znajdziesz w sekcji Przekazywanie obrazów.

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-preview-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-preview-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-preview-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-preview-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

Inne tryby generowania obrazów

Gemini obsługuje inne tryby interakcji z obrazem na podstawie struktury promptu i kontekstu, w tym:

• Tekst na obrazy i tekst (przeplatany): generuje obrazy z powiązanym tekstem.
  • Przykład promptu: „Wygeneruj ilustrowany przepis na paellę”.
• Obrazy i tekst na obrazy i tekst (przeplatany): na podstawie podanych obrazów i tekstu tworzy nowe powiązane obrazy i tekst.
  • Przykład promptu: (z obrazem umeblowanego pokoju) „Jaki inny kolor sofy pasowałby do mojego pokoju? Czy możesz zaktualizować obraz?”
• Wieloetapowe edytowanie obrazów (czat): możesz generować i edytować obrazy w ramach rozmowy.
  • Przykładowe prompty: [prześlij zdjęcie niebieskiego samochodu] , „Zamień ten samochód w kabriolet”, „Zamień teraz kolor na żółty”.

Ograniczenia

• Aby zapewnić najlepszą skuteczność, używaj tych języków: EN, es-MX, ja-JP, zh-CN, hi-IN.
• Generowanie obrazu nie obsługuje danych wejściowych audio ani wideo.
• Generowanie obrazów może nie zostać uruchomione, jeśli:
  • Model może zwracać tylko tekst. Spróbuj wyraźnie poprosić o wygenerowanie obrazu (np. „wygeneruj obraz”, „prześlij obrazy w miarę potrzeby”, „zaktualizuj obraz”).
  • Model może przestać generować dane w połowie procesu. Spróbuj ponownie lub użyj innego prompta.
• Podczas generowania tekstu na potrzeby obrazu Gemini działa najlepiej, jeśli najpierw wygenerujesz tekst, a potem poprosisz o obraz z tekstem.
• Generowanie obrazów jest niedostępne w niektórych regionach i krajach. Więcej informacji znajdziesz w sekcji Modele.

generować obrazy za pomocą modeli Imagen;

Ten przykład pokazuje generowanie obrazów za pomocą modelu Imagen:

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-4.0-generate-preview-06-06',
    prompt='Robot holding a red skateboard',
    config=types.GenerateImagesConfig(
        number_of_images= 4,
    )
)
for generated_image in response.generated_images:
  generated_image.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-4.0-generate-preview-06-06',
    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-4.0-generate-preview-06-06",
      "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-4.0-generate-preview-06-06:predict?key=GEMINI_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
        "instances": [
          {
            "prompt": "Robot holding a red skateboard"
          }
        ],
        "parameters": {
          "sampleCount": 4
        }
      }'

Konfiguracja usługi Imagen

Obecnie Imagen obsługuje tylko prompty w języku angielskim i te parametry:

• numberOfImages: liczba obrazów do wygenerowania, od 1 do 4 (włącznie). Wartość domyślna to 4. W przypadku Imagen 4 Ultra domyślnie ustawiona jest wartość 1, ponieważ naraz można wygenerować tylko jeden obraz.
• aspectRatio: zmienia format obrazu wygenerowanego przez AI. Obsługiwane wartości to "1:1", "3:4", "4:3", "9:16" i "16:9". Wartość domyślna to "1:1".

• personGeneration: zezwalaj modelowi na generowanie obrazów przedstawiających ludzi. Obsługiwane są te wartości:

  • "dont_allow": blokowanie generowania obrazów przedstawiających ludzi.
  • "allow_adult": generowanie obrazów przedstawiających dorosłych, ale nie dzieci. To jest ustawienie domyślne.
  • "allow_all": generowanie obrazów przedstawiających dorosłych i dzieci.

Wybór odpowiedniego modelu

Wybierz Gemini, jeśli:

• Potrzebujesz obrazów dopasowanych do kontekstu, które wykorzystują wiedzę i rozumowanie.
• Ważne jest, aby tekst i obrazy płynnie się ze sobą łączyły.
• Chcesz umieścić dokładne elementy wizualne w długich sekwencjach tekstowych.
• Chcesz edytować obrazy w sposób konwersacyjny, zachowując kontekst.

Wybierz Obraz, jeśli:

• Najważniejsze są jakość obrazu, fotorealizm, szczegóły artystyczne lub określone style (np. impresjonizm, anime).
• wykonywanie specjalistycznych zadań edytowania, takich jak aktualizacja tła produktu lub skalowanie obrazu;
• Umieszczanie logo, logotypów lub elementów stylu marki w projektach produktów.

Imagen 4 powinien być modelem, którego używasz do generowania obrazów za pomocą Imagen. Wybierz Imagen 4 Ultra w zaawansowanych zastosowaniach lub gdy potrzebujesz najlepszej jakości obrazu. Pamiętaj, że Imagen 4 Ultra może generować tylko jeden obraz naraz.

Przewodnik po promptach w usłudze Imagen

W tej sekcji przewodnika po Imagen dowiesz się, jak modyfikowanie promptu tekst-obraz może wpływać na uzyskiwane wyniki. Znajdziesz tu też przykłady obrazów, które możesz utworzyć.

Podstawy pisania promptów

Dobry prompt jest opisowy i jasny oraz zawiera znaczące słowa kluczowe i modyfikatory. Zacznij od określenia przedmiotu, kontekstu i stylu.

1. Temat: pierwszą rzeczą, o której należy pomyśleć, jest temat: obiekt, osoba, zwierzę lub krajobraz, którego chcesz stworzyć zdjęcie.

2. Kontekst i tło: równie ważne jest tło lub kontekst, w którym znajduje się obiekt. Spróbuj umieścić obiekt na różnych tłach. Może to być na przykład studio z białym tłem, plener lub wnętrze.

3. Styl: na koniec dodaj żądany styl obrazu. Style mogą być ogólne (obraz, fotografia, szkic) lub bardzo konkretne (obraz w pastelach, rysunek węglem, 3D izometryczne). Możesz też łączyć style.

Po napisaniu pierwszej wersji promptu dodaj do niego więcej szczegółów, aż uzyskasz pożądany obraz. Powtarzanie jest ważne. Najpierw określ główną ideę, a potem ją udoskonalaj i rozwijaj, aż wygenerowany obraz będzie zbliżony do Twojej wizji.

Modele Imagen mogą przekształcać Twoje pomysły w szczegółowe obrazy, niezależnie od tego, czy prompty są krótkie, czy długie i szczegółowe. Ulepszaj swoją wizję, korzystając z powtarzających się podpowiedzi i dodając szczegóły, aż uzyskasz idealny efekt.

Krótkie prompty umożliwiają szybkie generowanie obrazów.

Dłuższe prompty umożliwiają dodawanie konkretnych szczegółów i tworzenie obrazu.

Dodatkowe wskazówki dotyczące pisania promptów w usłudze Imagen:

• Używaj języka opisowego: stosuj szczegółowe przymiotniki i przysłówki, aby przedstawić Imagenowi jasny obraz.
• Podaj kontekst: w razie potrzeby dodaj informacje ogólne, aby pomóc AI w zrozumieniu.
• Użycie elementów pochodzących od konkretnych artystów lub stylów: jeśli masz na myśli konkretny styl, możesz posłużyć się elementami pochodzącymi od konkretnych artystów lub stylów artystycznych.
• Używanie narzędzi do tworzenia promptów: zastanów się nad wykorzystaniem narzędzi lub zasobów do tworzenia promptów, które pomogą Ci je ulepszać i osiągać optymalne wyniki.
• Ulepszenie szczegółów twarzy na zdjęciach osobistych i grupowych: określ szczegóły twarzy jako punkt skupienia zdjęcia (na przykład użyj słowa „portret” w promptzie).

Generowanie tekstu na obrazach

Modele Imagen mogą dodawać tekst do obrazów, co otwiera większe możliwości tworzenia obrazów. Aby w pełni korzystać z tej funkcji, postępuj zgodnie z tymi wskazówkami:

• Powtarzaj proces: może być konieczne ponowne wygenerowanie obrazów, dopóki nie uzyskasz pożądanego wyglądu. Integracja tekstu w Imagen jest nadal udoskonalana i czasem najlepsze wyniki przynoszą wielokrotne próby.
• Skróć tekst: aby zapewnić optymalną generację, ogranicz tekst do maksymalnie 25 znaków.

• Wiele wyrażeń: eksperymentuj z 2 lub 3 wyrażeniami, aby podać dodatkowe informacje. Aby uzyskać przejrzystość kompozycji, nie używaj więcej niż 3 wyrazów.

  

• Pozycja przewodnika: chociaż Imagen może próbować umieścić tekst zgodnie z instrukcjami, należy się spodziewać sporadycznych zmian. Ta funkcja jest stale ulepszana.

• Styl czcionki: określ ogólny styl czcionki, aby subtelnie wpływać na wybory dokonywane przez Imagena. Nie polegaj na dokładnym odwzorowaniu czcionek, ale spodziewaj się kreatywnych interpretacji.

• Rozmiar czcionki: określ rozmiar czcionki lub ogólny rozmiar (np. mały, średni, duży), aby wpływać na generowanie rozmiaru czcionki.

Parametryzowanie promptów

Aby lepiej kontrolować wyniki wyjściowe, warto skonfigurować parametry wejściowe w Imagen. Załóżmy na przykład, że chcesz, aby Twoi klienci mogli generować logo swojej firmy, i chcesz mieć pewność, że logo będą zawsze generowane na jednolitym tle. Musisz też ograniczyć opcje, które klient może wybrać z menu.

W tym przykładzie możesz utworzyć prompt z parametrami podobny do tego:

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

W niestandardowym interfejsie użytkownika klient może wpisywać parametry za pomocą menu, a wybrana przez niego wartość wypełnia prompt, który otrzymuje Imagen.

Na przykład:

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

   

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

   

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

   

Zaawansowane techniki pisania promptów

Korzystając z podanych niżej przykładów, możesz tworzyć bardziej szczegółowe prompty na podstawie atrybutów, takich jak opisy zdjęć, kształty i materiały, historyczne kierunki w sztuce oraz modyfikatory jakości obrazu.

Fotografia

• Prompt: „Zdjęcie…”

Aby użyć tego stylu, zacznij od użycia słów kluczowych, które wyraźnie informują Imagen, że szukasz zdjęcia. Rozpocznij prompta od słów "Zrób zdjęcie. . .". Przykład:

^{Źródło obrazu: każdy obraz został wygenerowany za pomocą odpowiedniego promptu tekstowego za pomocą modelu Imagen 3.}

Modyfikatory fotografii

W następnych przykładach znajdziesz kilka modyfikatorów i parametrów związanych z fotografią. Aby uzyskać większą kontrolę, możesz łączyć ze sobą wiele modyfikatorów.

1. Odległość od aparatu – zbliżenie, zrobione z dużej odległości

2. Pozycja kamery – powietrzna, od dołu

3. Oświetlenie – naturalne, dramatyczne, ciepłe, zimne

4. Ustawienia aparatu - rozmycie w ruchu, miękki fokus, bokeh, tryb portretowy

5. Typy obiektywów – 35 mm, 50 mm, rybie oko, szerokokątny, makro

6. Typy filmów – czarno-biały, polaroid

^{Źródło obrazu: każdy obraz został wygenerowany za pomocą odpowiedniego promptu tekstowego za pomocą modelu Imagen 3.}

Ilustracje i dzieła sztuki

• Prompt: "A painting of...", „sketch z…”

Style artystyczne mogą być monochromatyczne, jak szkice ołówkiem, lub hiperrealistyczne, jak sztuka cyfrowa. Na przykład te obrazy używają tego samego prompta w różnych stylach:

"An [art style or creation technique] of an angular sporty electric sedan with skyscrapers in the background"

^{Źródło obrazu: każdy obraz został wygenerowany za pomocą odpowiedniego promptu tekstowego przy użyciu modelu Imagen 2.}

Kształty i materiały

• Prompt: "...made of...", „…w kształcie…”

Jedną z zalet tej technologii jest to, że umożliwia ona tworzenie obrazów, które w innym przypadku byłyby trudne lub niemożliwe do uzyskania. Możesz na przykład odtworzyć logo swojej firmy w różnych materiałach i teksturach.

^{Źródło obrazu: każdy obraz został wygenerowany za pomocą odpowiedniego promptu tekstowego za pomocą modelu Imagen 3.}

odniesienia do dzieł sztuki z przeszłości,

• Prompt: "...w stylu..."

Niektóre style stały się z latami ikonami. Poniżej znajdziesz kilka pomysłów na malarstwo historyczne lub style artystyczne, które możesz wypróbować.

"wygeneruj obraz w stylu [art period or movement] : farma wiatrowa"

^{Źródło obrazu: każdy obraz został wygenerowany za pomocą odpowiedniego promptu tekstowego za pomocą modelu Imagen 3.}

Modyfikatory jakości obrazu

Niektóre słowa kluczowe mogą informować model, że szukasz zasobu wysokiej jakości. Przykłady modyfikatorów jakości:

• Modyfikatory ogólne – wysokiej jakości, piękne, stylizowane
• Zdjęcia – 4K, HDR, zdjęcie w Studio
• Grafika, ilustracja – wykonane przez profesjonalistę, szczegółowe

Poniżej znajdziesz kilka przykładów promptów bez modyfikatorów jakości i tego samego prompta z modyfikatorami jakości.

^{Źródło obrazu: każdy obraz został wygenerowany za pomocą odpowiedniego promptu tekstowego za pomocą modelu Imagen 3.}

Formaty obrazu

Generowanie obrazów w Imagen umożliwia ustawienie 5 różnych współczynników proporcji obrazu.

1. Kwadrat (1:1, domyślnie) – standardowe zdjęcie w formacie kwadratowym. Ten format jest często używany w przypadku postów w mediach społecznościowych.

2. Pełny ekran (4:3) – ten format jest często używany w mediach i filmach. Są to też wymiary większości starszych telewizorów (niepanoramowych) i kamer średniego formatu. Pozwala ono uchwycić więcej sceny w orientacji poziomej (w porównaniu z formatem 1:1), co czyni go preferowanym formatem w fotografii.

3. Pełny ekran pionowy (3:4) – to format pełnoekranowy obrócony o 90 stopni. Pozwala to uchwycić więcej szczegółów w pionie niż w formacie 1:1.

4. Panorama (16:9) – ten format zastąpił format 4:3 i jest obecnie najczęściej stosowanym formatem w telewizorach, monitorach i ekranach telefonów komórkowych (w orientacji poziomej). Użyj tego formatu, jeśli chcesz uchwycić więcej tła (np. krajobraz).

   

5. Pionowa (9:16) – ten format jest panoramiczny, ale obrócony. To stosunkowo nowy format obrazu, który stał się popularny dzięki aplikacjom do tworzenia krótkich filmów (np. YouTube Shorts). Używaj tego w przypadku wysokich obiektów o wyraźnie pionowej orientacji, takich jak budynki, drzewa, wodospady lub inne podobne obiekty.

   

fotorealistyczne obrazy

Różne wersje modelu do generowania obrazów mogą oferować zarówno wyniki o charakterze artystycznym, jak i realistyczne. Aby wygenerować bardziej fotorealistyczne wyniki na podstawie żądanego obiektu, użyj w promptach następującego sformułowania.

Portrety

Na podstawie kilku słów kluczowych z tabeli Imagen może wygenerować te portrety:

Prompt: Kobieta, portret 35 mm, duotony w kolorach niebieskim i szarym
Model: imagen-3.0-generate-002

Prompt: Kobieta, portret 35 mm, film noir
Model: imagen-3.0-generate-002

Obiekty

Korzystając z kilku słów kluczowych z tabeli, Imagen może wygenerować te obrazy obiektów:

Prompt: liść modlitwy, obiektyw makro, 60 mm
Model: imagen-3.0-generate-002

Prompt: talerz z makaronem, obiektyw makro 100 mm
Model: imagen-3.0-generate-002

Ruch

Korzystając z kilku słów kluczowych z tabeli, Imagen może wygenerować te obrazy w ruchu:

Prompt: wygrywający touchdown, szybka szybkość migawki, śledzenie ruchu
Model: imagen-3.0-generate-002

Prompt: Rzeczywistego jelenia biegającego po lesie, szybka szybkość migawki, śledzenie ruchu
Model: imagen-3.0-generate-002

Szerokokątny

Korzystając z kilku słów kluczowych z tabeli, Imagen może wygenerować te zdjęcia panoramiczne:

Prompt: rozległy łańcuch górski, tryb poziomy, kąt widzenia 10 mm
Model: imagen-3.0-generate-002

Prompt: zdjęcie księżyca, fotografia astronomiczna, obiektyw szerokokątny 10 mm
Model: imagen-3.0-generate-002

Co dalej?

• Aby dowiedzieć się, jak generować filmy za pomocą interfejsu Gemini API, zapoznaj się z przewodnikiem Veo.
• Więcej informacji o modelach Gemini znajdziesz w artykułach Modele Gemini i Modele eksperymentalne.