Using Photography Modifiers

Welcome to the next step in your journey of creating stunning AI-generated images! In the previous lesson, you explored how artistic styles and quality modifiers can enhance the visual output of your images.

Now, we will build on that foundation by introducing you to photography modifiers. These modifiers are crucial for adding realism and artistic flair to your images, allowing you to simulate various photographic techniques and styles.

Photography modifiers include elements such as camera proximity, camera position, lighting, camera settings, lens types, and film types. By incorporating these into your prompts, you can guide the AI to generate images that mimic real-world photography, providing a more immersive and authentic visual experience.

Let's delve into the different types of photography modifiers and understand their impact on image aesthetics. These modifiers allow you to simulate various photographic techniques, enhancing the realism and artistic quality of your images.

• Camera Proximity: This modifier affects how close or far the camera appears to be from the subject. For example, a close-up shot can highlight details, while a zoomed-out shot provides a broader context.

• Camera Position: This refers to the angle or perspective from which the photo is taken. An aerial view can offer a bird's-eye perspective, while a shot from below can create a sense of grandeur.

• Lighting: Lighting modifiers can dramatically change the mood of an image. Natural lighting provides a soft, realistic look, while dramatic lighting can add intensity and focus.

• Camera Settings: These include effects like motion blur, soft focus, and bokeh, which can add depth and artistic flair to your images.

• Lens Types: Different lenses, such as fisheye or macro, can alter the field of view and distortion, creating unique visual effects.

• Film Types: This modifier can simulate the look of different film types, such as black and white or Polaroid, adding a vintage or classic feel to your images.

By understanding and utilizing these modifiers, you can create images that not only look realistic but also convey the desired artistic expression.

Now, let's see how to implement these photography modifiers in your code. We'll use the provided code snippet to demonstrate how to define prompts with specific photography styles and generate images.

In the code, we start by setting up a Guzzle HTTP client and pointing it at the Gemini API's generateContent endpoint for gemini-3.1-flash-image. This endpoint serves as the connection between your code and the Gemini API.

We then define a list of prompts, each incorporating different photography modifiers:

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;

// Load API key from environment
$apiKey = getenv("GEMINI_API_KEY");
if (!$apiKey) {
    die("GEMINI_API_KEY environment variable not set.\n");
}

// Define endpoint
$endpoint = getenv("GEMINI_BASE_URL") . "?key=" . $apiKey;

// Define prompts with photography-based modifiers
$photoModifiers = [
    "A dramatic portrait of an old man, shot with a Canon 5D, f/1.8 aperture, natural lighting",
    "A breathtaking mountain landscape, golden hour, taken with a Sony Alpha, HDR",
    "A cozy cafe scene, cinematic lighting, bokeh effect, DSLR-quality",
    "A street in New York City, taken with a fisheye lens, wide-angle perspective",
    "An aerial view of a lush rainforest, captured from a drone"
];

For each prompt, we use the HTTP client to post a generateContent request to the Gemini API. The request body follows the Gemini contents/parts structure, where the prompt text is placed inside a parts array.

Any visual intent — such as aspect ratio or photographic style — is expressed directly in the prompt text itself rather than as separate API parameters.

Let's walk through an example to see how these concepts come together in practice. We'll use the code provided to generate images with different photography modifiers.

<?php

$client = new Client();

foreach ($photoModifiers as $photoPrompt) {
    $payload = [
        "contents" => [
            [
                "parts" => [
                    ["text" => $photoPrompt]
                ]
            ]
        ],
        "generationConfig" => [
            "responseModalities" => ["TEXT", "IMAGE"]
        ]
    ];

    try {
        $response = $client->post($endpoint, [
            'headers' => [
                'Content-Type' => 'application/json'
            ],
            'json' => $payload
        ]);

        $statusCode = $response->getStatusCode();

        $body = json_decode($response->getBody(), true);

        $outputDir = 'public/images/';
        if (!is_dir($outputDir)) {
            mkdir($outputDir, 0777, true);
        }

        if (!empty($body['candidates'])) {
            foreach ($body['candidates'] as $candidate) {
                if (!empty($candidate['content']['parts'])) {
                    foreach ($candidate['content']['parts'] as $partIndex => $part) {
                        if (!empty($part['inlineData'])) {
                            $mimeType = $part['inlineData']['mimeType'];
                            $imageData = base64_decode($part['inlineData']['data']);

                            $extension = match ($mimeType) {
                                'image/jpeg' => 'jpg',
                                'image/webp' => 'webp',
                                default      => 'png',
                            };

                            $timestamp = time();
                            $filename = 'image_' . $timestamp . '_' . $partIndex . '.' . $extension;
                            $outputPath = $outputDir . $filename;

                            file_put_contents($outputPath, $imageData);
                            echo "Image saved as $outputPath\n";
                        }
                    }
                }
            }
        } else {
            echo "No images found in response:\n";
            print_r($body);
        }

    } catch (RequestException $e) {
        echo "API request failed.\n";
        if ($e->hasResponse()) {
            echo "Response:\n" . $e->getResponse()->getBody();
        } else {
            echo $e->getMessage();
        }
    }
}

In this example, we loop through each prompt and send it to the Gemini API. The response is navigated through candidates -> content -> parts, and only parts that contain an inlineData key — indicating an image — are saved.

The MIME type returned by Gemini (for example, image/png or image/jpeg) is used to choose the correct file extension automatically. The generated images are saved to public/images/ and will reflect the specified photography modifiers.

For instance, a portrait with natural lighting will have a soft, realistic appearance, while a fisheye lens prompt will produce a wide-angle perspective.

The following image was generated using the prompt: "A dramatic portrait of an old man, shot with a Canon 5D, f/1.8 aperture, natural lighting". Notice how the modifiers contribute to the realistic skin textures and the soft background blur (bokeh) typical of a wide aperture lens.

In this lesson, you learned about the different types of photography modifiers and how to implement them in your image generation code. By incorporating these modifiers into your prompts, you can create images that mimic real-world photography, enhancing both realism and artistic expression.

As you move on to the practice exercises, take the opportunity to experiment with different combinations of photography modifiers. This hands-on practice will reinforce your understanding and prepare you for more advanced topics in the upcoming lessons. Keep exploring and enjoy the journey of creating stunning images with AI!