Column Name	Type	Computed With
prompt	String
source_image	Image

prompt	source_image
Create a scene of lush solarpunk metropolis in the desert with urban agriculture and an oasis theme.It should not look like an office park, corporate campus, or an outdoor mall.

prompt	new_image
Create a scene of lush solarpunk metropolis in the desert with urban agriculture and an oasis theme.It should not look like an office park, corporate campus, or an outdoor mall.

new_image_fileurl
file:///Users/alison-pxt/.pixeltable/media/da204656b7d04472b880dd50f21f4a36/d9/d93c/da204656b7d04472b880dd50f21f4a36_10_9_d93c75d98807435e889092aaa5e9e52b.jpeg

prompt	new_image	new_image_sq
Create a scene of lush solarpunk metropolis in the desert with urban agriculture and an oasis theme.It should not look like an office park, corporate campus, or an outdoor mall.

Now, we’ll insert values for our first row. We need to provide a text prompt for the `reve.create()` function and a source image for the `reve.edit()` function. ```python theme={null} scene_prompt = ( 'Create a scene of lush solarpunk metropolis in the desert ' 'with urban agriculture and an oasis theme.' 'It should not look like an office park, corporate campus, or an outdoor mall.' ) image_url = 'https://raw.githubusercontent.com/pixeltable/pixeltable/main/docs/resources/images/000000000036.jpg' ``` ```python theme={null} spunk_t.insert([{'prompt': scene_prompt, 'source_image': image_url}]) ```

  Inserted 1 row with 0 errors in 0.03 s (39.10 rows/s)
  1 row inserted.

To read more about inserting data, see [Bringing Data](/howto/cookbooks/data/data-import-csv). And we can peek at our starter table with a single row: ```python theme={null} spunk_t.collect() ```

## Generate new imagery with Reve Create Use `reve.create()` when you want Reve to synthesize an entirely new image from a prompt. In Pixeltable, we place this function call inside a computed column. We’ll generate fresh imagery from the prompt first in this section. Feel free to change the prompt. Here we ask for a solarpunk oasis city. ```python theme={null} from pixeltable.functions import reve spunk_t.add_computed_column( new_image=reve.create(spunk_t.prompt), if_exists='replace' ) ```

  Added 1 column value with 0 errors in 6.16 s (0.16 rows/s)
  1 row updated.

To read more about computed columns in Pixeltable, see [Computed Columns](/tutorials/computed-columns). ```python theme={null} spunk_t.select(spunk_t.prompt, spunk_t.new_image).collect() ```

By default, Pixeltable saves all generated media outputs to a media directory. We can see the file path by using the `fileurl` property. ```python theme={null} spunk_t.select(spunk_t.new_image.fileurl).collect() ```

### Add Reve parameters All Reve functions accept optional parameters to customize the output: * `aspect_ratio`: desired image aspect ratio, e.g. ‘3:2’, ‘16:9’, ‘1:1’, etc. (available for `reve.create()` and `reve.remix()`) * `version`: specific model version to use (optional; defaults to latest if not specified). Available for all Reve functions (`reve.create()`, `reve.edit()`, and `reve.remix()`) This adds a second image column using the same prompt that renders in a square frame. ```python theme={null} spunk_t.add_computed_column( new_image_sq=reve.create(spunk_t.prompt, aspect_ratio='1:1'), if_exists='replace', ) ```

  Added 1 column value with 0 errors in 6.22 s (0.16 rows/s)
  1 row updated.

```python theme={null} spunk_t.select( spunk_t.prompt, spunk_t.new_image, spunk_t.new_image_sq ).collect() ```

To read more about `reve.create()`, see [reve.create UDF](/sdk/latest/reve#udf-create). ## Edit an existing photo with Reve Edit `reve.edit()` takes an existing image plus natural-language instructions and returns an edited version. We already have a `source_image` column in our table from the initial setup. ```python theme={null} spunk_t.select(spunk_t.source_image).collect() ```

We can now add a computed column that calls `reve.edit()` to modify the source image. To read more about `reve.edit()`, see [reve.edit UDF](/sdk/latest/reve#udf-edit). This editing prompt is integrated into our computed column logic in Pixeltable, as opposed to our creating example where we saved the prompt as its own column. This means that the same prompt will be applied to any new rows that we insert into this table. We will phrase the editing prompt to reflect this table’s solarpunk theme, but otherwise keep it general. This way, we don’t need to provide a specific prompt for every new table row. ```python theme={null} # Uncomment the below line to use a Reve function, if you have not already done so # from pixeltable.functions import reve spunk_t.add_computed_column( edited_subject=reve.edit( spunk_t.source_image, 'Remove any existing background. Focus on the closest person in the foreground. ' 'Keep the person and props, but make the lighting and colors vibrant and fit with a solarpunk theme. ' 'Make the background behind the person blank.', ), if_exists='replace', ) ```

  Added 1 column value with 0 errors in 16.54 s (0.06 rows/s)
  1 row updated.

We can use `collect()` to see the new image: ```python theme={null} spunk_t.select(spunk_t.source_image, spunk_t.edited_subject).collect() ```

## Remix multiple references with Reve Remix `reve.remix()` blends multiple reference images. Inside the prompt string, you reference each image with a numbered placeholder: * `0` refers to `images[0]` * `1` refers to `images[1]` * etc. You can optionally specify `aspect_ratio` and `version` parameters (both default to latest/auto if not specified). In the next cell we place the edited subject from `0` (the first entry in the images list) into the scene from `1` (the second entry). ```python theme={null} # Uncomment the below line to use a Reve function, if you have not already done so # from pixeltable.functions import reve spunk_t.add_computed_column( solarpunk_remix=reve.remix( 'Place the person in 0 in the foreground of the scene from 1. ' 'Make the background clear and detailed so it feels like a complete "day in the life" in solarpunk city scene.', images=[spunk_t.edited_subject, spunk_t.new_image], aspect_ratio='16:9', ), if_exists='replace', ) ```

  Added 1 column value with 0 errors in 18.58 s (0.05 rows/s)
  1 row updated.

To read more about `reve.remix()`, see [reve.remix UDF](/sdk/latest/reve#udf-remix). ```python theme={null} spunk_t.select(spunk_t.solarpunk_remix).collect() ```

## Insert a new row So far, we have been building up our table schema with a single row. Now we’ll insert a new row, with two fresh input values: 1. A text prompt to create the scene image with `reve.create()` and 2. A source image to edit with `reve.edit()` and remix into that scene with `reve.remix()`. Pixeltable will then automatically make the desired Reve API calls and populate the computed columns. ```python theme={null} spunk_t.insert( [ { 'prompt': 'Create an indoor tennis court scene, with clay courts inside a lush solarpunk greenhouse filled with bougainvillea, terraced gardens, and an oasis theme.', 'source_image': 'https://raw.githubusercontent.com/pixeltable/pixeltable/main/docs/resources/images/000000000885.jpg', } ] ) ```

  Inserted 1 row with 0 errors in 34.30 s (0.03 rows/s)
  1 row inserted.

Now we can inspect both outputs because the `insert()` in Pixeltable triggers our computed columns to update for any that are missing values (existing images we already generated are not changed because Pixeltable does incremental updates). For example, here is our inserted image and our edited image: ```python theme={null} spunk_t.select(spunk_t.source_image, spunk_t.edited_subject).collect() ```

Here are our two remixed images created by Reve: ```python theme={null} spunk_t.select(spunk_t.solarpunk_remix).collect() ```

All together, we created a new scene image, edited an existing image of a person, then remixed both together to reimagine an existing person in our new scene. ```python theme={null} spunk_t.select( spunk_t.new_image, spunk_t.edited_subject, spunk_t.solarpunk_remix ).collect() ```

## Review Reve in Pixeltable Below is a quick recap of how each Reve function maps inputs to outputs inside Pixeltable tables. Each function reads input parameters and writes its results into computed columns. ### Reve Create * **Input parameter:** A prompt inserted as a row inside a Pixeltable ```python theme={null} spunk_t.select( spunk_t.prompt, spunk_t.new_image, spunk_t.new_image_sq ).collect() ```

### Reve Edit * **Input parameter:** A source image of type `pxt.Image` * **Usage reminder:** The edit instructions live inline inside the `add_computed_column()` call ```python theme={null} spunk_t.select(spunk_t.source_image, spunk_t.edited_subject).collect() ```

### Reve Remix * **Input parameters:** We started with two image columns * **How the prompt references them:** * `images=[my_table.image00, my_table.image01]` * Inside the prompt, `0` points at `images[0]` and `1` points at `images[1]` * **Usage reminder:** Always keep the placeholders and the order of the `images` list in sync; add more `n` tags if you pass more reference images. ```python theme={null} spunk_t.select( spunk_t.new_image, spunk_t.edited_subject, spunk_t.solarpunk_remix ).collect() ```

## Learn more * Reve API reference: [https://api.reve.com/console/docs](https://api.reve.com/console/docs) * Pixeltable documentation: [https://docs.pixeltable.com/sdk/latest/reve#module-pixeltable-functions-reve](/sdk/latest/reve#module-pixeltable-functions-reve) If you build something with Reve, let us know! Built with [Mintlify](https://mintlify.com).

prompt	new_image	new_image_sq
Create a scene of lush solarpunk metropolis in the desert with urban agriculture and an oasis theme.It should not look like an office park, corporate campus, or an outdoor mall.
Create an indoor tennis court scene, with clay courts inside a lush solarpunk greenhouse filled with bougainvillea, terraced gardens, and an oasis theme.

source_image	edited_subject

solarpunk_remix

new_image	edited_subject	solarpunk_remix

source_image	edited_subject