Fresh clone

app.py

@@ -12,10 +12,14 @@ import uuid
 from time import sleep
 import json
 from functions import combine_images_side_by_side
+from poses import poses
 from typing import Optional
-
+from base64 import decodebytes
 from dotenv import load_dotenv
+import random
+import asyncio
 load_dotenv()
+import ast
 
 
 app = FastAPI()
@@ -26,319 +30,316 @@ r = redis.Redis(
   host='cute-wildcat-41430.upstash.io',
   port=6379,
   password='AaHWAAIjcDFhZDVlOGUyMDQ0ZGQ0MTZmODA4ZjdkNzc4ZDVhZjUzZHAxMA',
-  ssl=True
+  ssl=True,
+  decode_responses=True
 )
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
 
 @app.post("/virtualTryOn", summary="Virtual try on single call", 
     description="Virtual try on single call for complete outfit try on")
 async def virtual_try_on(
     background_tasks: BackgroundTasks,
-    talent_trigger_word: str = Form(...),
-    talent_lora_url: str = Form(...),
-    num_images: int = 4,
-    top_garment_image: UploadFile = File(...), 
-    bottom_garment_image: UploadFile = File( None),
-    top_back_garment_image: UploadFile = File(None), 
-    bottom_back_garment_image: UploadFile = File(None)):
+    num_images: int = 2,
+    num_variations: int = 2,
+    person_reference: str = "",
+    person_image: UploadFile = File(None), 
+    person_face_image: UploadFile = File(None), 
+    garment_image_1: UploadFile = File(None), 
+    garment_image_2: UploadFile = File(None),
+    garment_image_3: UploadFile = File(None), 
+    garment_image_4: UploadFile = File(None),):
     """
     Pass in the top garment image, bottom garment image, top back garment image, bottom back garment image, talent trigger word, talent lora url and number of images to generate.
     Only one front garment image is required, the rest are optional.
     Default number of images is 4.
     """
-    print(top_garment_image)
     request_id = str(uuid.uuid4())
     r.set(request_id, "pending")
-    
+    print("request_id: ", request_id)
+    model_images = []
+    garment_images = [] 
     # Read all files first
-    top_garment_data = await safe_read_file(top_garment_image)
-    bottom_garment_data = await safe_read_file(bottom_garment_image)
-    top_back_garment_data = await safe_read_file(top_back_garment_image)
-    bottom_back_garment_data = await safe_read_file(bottom_back_garment_image)
+    person_image_data = await safe_read_file(person_image)
+    person_face_image_data = await safe_read_file(person_face_image)
+    if person_image is not None:
+        model_images.append(person_image_data)
+    if person_face_image is not None:
+        model_images.append(person_face_image_data)
+    if garment_image_1 is not None:
+        garment_image_1_data = await safe_read_file(garment_image_1)
+        garment_images.append(garment_image_1_data)
+    if garment_image_2 is not None:
+        garment_image_2_data = await safe_read_file(garment_image_2)
+        garment_images.append(garment_image_2_data)
+    if garment_image_3 is not None:
+        garment_image_3_data = await safe_read_file(garment_image_3)
+        garment_images.append(garment_image_3_data)
+    if garment_image_4 is not None:
+        garment_image_4_data = await safe_read_file(garment_image_4)
+        garment_images.append(garment_image_4_data)
     
     # Launch background task with the actual data
     background_tasks.add_task(
         run_virtual_tryon_pipeline,
         request_id,
-        top_garment_data,
-        bottom_garment_data,
-        top_back_garment_data,
-        bottom_back_garment_data,
-        talent_trigger_word,
-        talent_lora_url,
-        num_images
+        person_reference,
+        model_images,
+        garment_images,
+        num_images,
+        num_variations
     )
     return {"request_id": request_id}
 
-@app.get("/status/{request_id}")
-async def check_status(request_id: str):
-    status = r.get(request_id)
-    if not status:
-        return {"error": "Invalid request_id"}
-    return {"request_id": request_id, "status": status}
-
-#endpoints related to base image generation
-
-@app.get("/makeBaseImage", summary="Make a base image of the character,before adding the outfit",
-    description="Make one or more base image(s) of the character,before adding the outfit. supports multiple poses by passing in a list of pose ids")
-async def make_base_image(character_lora: str, character_keyword: str, outfit_desc: str, pose_id: int , num_outputs: int = 1):
-    """
-    Pass in the character lora, character keyword, outfit description and pose id to make a base image of the character,before adding the outfit. 
-    supports multiple poses by passing a number of outputs.
-    """
-    print("make base image")
-    result = base_generator.create_image(character_lora, character_keyword, outfit_desc, pose_id, num_outputs   )
-    return(result)
-
-# Function related to virtual outfit try on
-async def safe_read_file(file: UploadFile):
-    print("safe read file")
-    print(file)
-    if file is None:
-        return None
-    content = await file.read()
-    return content if content else None
-
 
 async def run_virtual_tryon_pipeline(
     request_id,
-    top_garment_data: bytes,
-    bottom_garment_data: bytes,
-    top_back_garment_data: bytes,
-    bottom_back_garment_data: bytes,
-    talent_trigger_word,
-    talent_lora_url,
-    num_images
+    person_reference,
+    model_images: list,
+    garment_images: list,
+    num_images: int,
+    num_variations: int,
 ):
+    output_images = []
     try:
+        #Step 1: Check incoming data
         r.set(request_id, "checking incoming data...")
-        front_type = ""
-        back_type = ""
-        
-        # Now we can use the data directly
-        if top_garment_data is None and bottom_garment_data is None:
-            return {"error": "Missing garment images"}
-            
-        if top_garment_data and bottom_garment_data:
-            front_type = "double"
-        elif top_garment_data or bottom_garment_data:
-            front_type = "single"
-        else:
-            front_type = "none"
 
-        if top_back_garment_data and bottom_back_garment_data:
-            back_type = "double"
-        elif top_back_garment_data or bottom_back_garment_data:
-            back_type = "single"
-        else:
-            back_type = "none"
-
-        print(f"front_type: {front_type}")
-        print(f"back_type: {back_type}")
-        front_final_image = ""
-        back_final_image = ""
-
-        if front_type == "double":
-            front_final_image = await combine_images_side_by_side(top_garment_data, bottom_garment_data)
-        if back_type == "double":
-            back_final_image = await combine_images_side_by_side(top_back_garment_data, bottom_back_garment_data)
-        if front_type == "single":
-            front_final_image = top_garment_data or bottom_garment_data
-        if back_type == "single":
-            back_final_image = top_back_garment_data or bottom_back_garment_data
-        r.set(request_id, "Garment images combined")   
-        #Check incoming data. do we have the required data. Are the images what we expect? (ie flatlay image file etc.)
-        #lets use openai for this. Also, return errors where needed
-        r.set(request_id, "Creating base image")
-        # STEP 1: make base image
-
-        ## analyse the garment images
-        garment_description = describe_garment(front_final_image)
+        #Step 2: Describe garment
+        r.set(request_id, "Describing garment")
+        garment_descriptions = []
+        for image in garment_images:
+            garment_description = await describe_garment(image)
+            garment_descriptions.append(garment_description)
+       
+       
+        #Step 4: Create prompt
+        r.set(request_id, "Creating prompt")
         try:
-            base_image = base_generator.create_image(talent_lora_url, talent_trigger_word, garment_description, 1, num_images)
-            print(f"base_image: {base_image}")
+            completed_outfit = await complete_outfit(garment_descriptions)
+            prompt = f"{person_reference} wearing {completed_outfit['description']} in front of a white background"
+            pose = random.choice(poses)
+            prompt += f" {pose}"
+            r.set(request_id + "_prompt", prompt)
         except Exception as e:
-            r.set(request_id, "error generating base image")
+            r.set(request_id, "error creating prompt")
             r.set(f"{request_id}_error", str(e))
+            print(f"error creating prompt: {e}")
             return
 
-        r.set(request_id, "Combining garment images")
-        sleep(5)
-
-        # STEP 2: combine garments
-        # ...
-
-        r.set(request_id, "Styling talent")
-        sleep(5)
-        # STEP 3: style the talent
-        # ...
+        #Step 5: Create base images
+        r.set(request_id, "Creating base images")
+        r.set(request_id + "_content", "")
+        try:    
+            base_images = await create_image(garment_images, model_images, prompt, num_images, request_id)
+            output_images.append(base_images)
+            r.set(request_id, "base images created")
+            print(str(base_images))
+            r.set(request_id + "_content", str(base_images))
+        except Exception as e:
+            r.set(request_id, "error creating base images")
+            r.set(f"{request_id}_error", str(e))
+            if isinstance(base_images, asyncio.Future):
+                base_images.cancel()
+            return
 
-        r.set(request_id, "Creating variations")
-        sleep(5)
-        # STEP 4: generate variations
-        # ...
+        #Step 6: Create variations
+        if num_variations > 0:
+            r.set(request_id, "Creating variations")
+            r.set(request_id + "_variations", "")   
+            try:
+                for image in base_images['images'  ]:
+                    variations = await make_versions(image['url'], num_variations)
+                output_images.append(variations)
+                r.set(request_id + "_variations", str(variations))
+                r.set(request_id, "variations created")
+            except Exception as e:
+                r.set(request_id, "error creating variations")
+                r.set(f"{request_id}_error", str(e))
+                return
+        else:
+            r.set(request_id, "no variations created")
 
-        r.set(request_id, "Upscaling images")
-        sleep(5)
-        # STEP 5: upscale
-        # ...
 
-        # STEP 6: Final result
-        final_result = {"images": ["url1", "url2"], "notes": "done"}
-        r.set(f"{request_id}_result", json.dumps(final_result))
+        #Step 7: Final result
+        r.set(request_id, "Final result")
+        result_images = get_result_images(request_id)
+        r.set(f"{request_id}_result", result_images)
         r.set(request_id, "completed")
+        return {"request_id": request_id, "status": "completed", "result": result_images}
     except Exception as e:
-        r.set(request_id, "error")
+        #r.set(request_id, "error")
         r.set(f"{request_id}_error", str(e))
+        return {"request_id": request_id, "status": "error", "error": str(e)}
+
+def get_result_images(request_id):
+    result_images = []
+    images = ast.literal_eval( r.get(request_id + "_content"))
+    print(type(images))
+    print("images coming here: ")
+    print(images)   
+    variations = ast.literal_eval(r.get(request_id + "_variations")["images"])
+    print("variations coming here: ")   
+    print(variations)
+    print("all images coming here: ")
+    all_images = images + variations
+    print(all_images)
+    for image in all_images:
+        result_images.append(image['url'])
+    return result_images
+
+@app.get("/result/{request_id}")
+async def check_status(request_id: str):
+    output_images = []
+    status = r.get(request_id)
+    images = ast.literal_eval( r.get(request_id + "_content"))
+    for image in images['images']:
+        output_images.append(image['url'])
+    variations = ast.literal_eval(r.get(request_id + "_variations"))
+    for image in variations['images']:
+        output_images.append(image['url'])
+    prompt = r.get(request_id + "_prompt")
+    result = r.get(request_id + "_result")
+    error = r.get(request_id + "_error")
+    if not status:
+        return {"error": "Invalid request_id"}
+    #return {"request_id": request_id, "status": status, "\n images": images, "\n variations": variations, "\n prompt": prompt, "\n result": result, "\n error": error}
+    return {"images": output_images }
 
 
-#figure out how to deal with front vs back images of garments
-
-
-def combine_garment_images(Upper_garment: UploadFile = File(...), Lower_garment: UploadFile = File(...)):
-    print("combine garment images")
-    result = base_generator.create_image()
-    return(result)
-    
-
-# Endpoints related to virtual outfit try on
-# HOW DO WE DICESERN FRONT VS BACK IMAGES OF GARMENTS?
-
-@app.post("/styleTalent", summary="Style talent", description="Style talent")
-async def style_talent( talent_image: UploadFile = File(...), garment_image: UploadFile = File(...)):
-    #Save the uploaded talent image tempoarily
-    talent_image_bytes = await talent_image.read()
-    file_path = f"/tmp/{talent_image.filename}"
-    with open(file_path, "wb") as f:
-        f.write(talent_image_bytes)
-
-    #Upload the file to FAL
-    talent_image_url = fal_client.upload_file(file_path)
-
-    #Save the uploaded garment image tempoarily
-    garment_image_bytes = await garment_image.read()
-    file_path = f"/tmp/{garment_image.filename}"
-    with open(file_path, "wb") as f:
-        f.write(garment_image_bytes)
-
-    #Upload the file to FAL
-    garment_image_url = fal_client.upload_file(file_path)
-
-    handler = fal_client.submit(
-    "fal-ai/kling/v1-5/kolors-virtual-try-on",
-    arguments={
-        "human_image_url": talent_image_url,
-        "garment_image_url": garment_image_url
-    },
-    )
-    request_id = handler.request_id
-    return(request_id)
-
-# Endpoints related to making more stills versions from image
-
-@app.get("/versionStatus")
-def versionStatus(request_id: str):
-    status = fal_client.status("fal-ai/instant-character", request_id, with_logs=True)
-    return(status)
-
-@app.get("/versionResult")
-async def versionResult(request_id: str):
-    result = await fal_client.result_async("fal-ai/instant-character", request_id)
-    return(result)
-
-
-@app.post("/makeVersions")
-async def make_versions(image: UploadFile = File(...)):
-    # Read image data
-    image_bytes = await image.read()
-
-    # Optional: prepare image payload for external API
-    files = {"file": (image.filename, BytesIO(image_bytes), image.content_type)}
+@app.get("/status/{request_id}")
+async def check_status(request_id: str):
+    status = r.get(request_id)
+    images = r.get(request_id + "_content")
+    variations = r.get(request_id + "_variations")
+    prompt = r.get(request_id + "_prompt")
+    result = r.get(request_id + "_result")
+    error = r.get(request_id + "_error")
+    if not status:
+        return {"error": "Invalid request_id"}
+    return {"request_id": request_id, "status": status, "\n images": images, "\n variations": variations, "\n prompt": prompt, "\n result": result, "\n error": error}
 
-    #Save the uploaded file tempoarily
-    file_path = f"/tmp/{image.filename}"
-    with open(file_path, "wb") as f:
-        f.write(image_bytes)
+#endpoints related to base image generation
 
-    #Upload the file to FAL
-    url = fal_client.upload_file(file_path)
-    
-    # Call external API
-    handler = fal_client.submit(
-    "fal-ai/instant-character",
-    arguments={
-        "prompt": "Model posing",
-        "image_url": url,
-        "num_inference_steps": 35,
-        "num_images": 2,
-    },
-    )
-    # Clean up file
-    os.remove(file_path)
-    request_id = handler.request_id
-    return(f"check request id: {request_id}")
+# Function related to virtual outfit try on
 
+async def safe_read_file(file: UploadFile):
+    print("safe read file")
+    #print(file)
+    if file is None:
+        #print("file is none")
+        return None
+    #print("file is not none")
+    content = await file.read()
+    #print("content read")
+    return content if content else None
 
 
 
+async def make_versions(input_image_url: str, num_images: int):
+    try:
+        # Call external API
+        handler = await fal_client.submit_async(
+            "fal-ai/instant-character",
+            arguments={
+                "prompt": "Model posing in front of white background",
+                "image_url": input_image_url,
+                "num_inference_steps": 50,
+                "num_images": num_images,
+                "safety_tolerance": "5",
+                "guidance_scale": 20,
+                "image_size": "portrait_16_9"
+            }
+        )
+        
+        # Get the result first
+        result = await handler.get()
+        
+        # Now we can safely iterate events
+        async for event in handler.iter_events(with_logs=False):
+            print(event)
+            
+        return result
+    except Exception as e:
+        print(f"Error in make_versions: {e}")
+        raise e
 
 
-# Endpoints related to image to video generation
 
-@app.post("/makeVideo")
-async def make_video(image: UploadFile = File(...)):
-    # Read image data
-    image_bytes = await image.read()
 
-    # Optional: prepare image payload for external API
-    files = {"file": (image.filename, BytesIO(image_bytes), image.content_type)}
+#Auxiliary functions
 
-    #Save the uploaded file tempoarily
-    file_path = f"/tmp/{image.filename}"
-    with open(file_path, "wb") as f:
-        f.write(image_bytes)
+#@app.post("/describeGarment", summary="Describe a garment or garments in the image",
+#    description="Passes the garment image to openai to describe it to improve generation of base images")
+#async def describe_garment(image: UploadFile = File(...)):
+
+async def create_image(garment_images: list, 
+    model_images: list,
+    prompt: str,
+    num_images: int,
+    request_id: str,    
+    ):
+    print("Lets create the images!")
+    #create urls for image
+    image_urls = []
+    img_no = 0
+    for image in garment_images:
+        #Save the uploaded file tempoarily
+        file_path = f"/tmp/img_{request_id}_{img_no}.jpg"
+        with open(file_path, "wb") as f:
+            f.write(image)
+        image_url = fal_client.upload_file(file_path)
+        image_urls.append(image_url)
+        os.remove(file_path)
+        #print("Garment image uploaded")
+        img_no += 1
+    for image in model_images:
+        file_path = f"/tmp/img_{request_id}_{img_no}.jpg"
+        with open(file_path, "wb") as f:
+            f.write(image)
+        image_url = fal_client.upload_file(file_path)
+        image_urls.append(image_url)
+        os.remove(file_path)
+        #print("Model image uploaded")
+
+
+    #Generate images using flux kontext
+    try:
+        handler = await fal_client.submit_async(
+            "fal-ai/flux-pro/kontext/multi",
+            arguments={
+                "prompt": prompt,
+                "guidance_scale": 18,
+                "num_images": num_images,
+                "safety_tolerance": "5",
+                "output_format": "jpeg",
+                "image_urls": image_urls,
+                "aspect_ratio": "9:16"
+            }
+        )
+        
+        # Get the result first before iterating events
+        result = await handler.get()
+        
+        # Now we can safely iterate events
+        async for event in handler.iter_events(with_logs=True):
+            print(event)
+        
+        return result
+    except Exception as e:
+        print(f"Error in create_image: {e}")
+        raise e
 
-    #Upload the file to FAL
-    url = fal_client.upload_file(file_path)
-    
-    # Call external API
-    handler = fal_client.submit(
-    "fal-ai/kling-video/v1.6/pro/image-to-video",
-        arguments={
-        "prompt": "Model moving between front facing fashion poses.",
-        "image_url": url,
-        "duration": "10",
-        "aspect_ratio": "9:16",
-        "negative_prompt": "blur, distort, and low quality, moire, warping, unrealistic, uncanny valley",
-        "cfg_scale": 0.5
-    },
-    )
-    # Clean up file
-    os.remove(file_path)
-    request_id = handler.request_id
-    return(f"check request id: {request_id}")
-
-@app.get("/videoStatus")
-def videoStatus(request_id: str):
-    status = fal_client.status("fal-ai/kling-video/v1.6/pro/image-to-video", request_id, with_logs=True)
-    return(status)
-
-@app.get("/videoResult")
-async def videoResult(request_id: str):
-    result = await fal_client.result_async("fal-ai/kling-video/v1.6/pro/image-to-video", request_id)
+    #print(result)
+    #print("Images generated")
     return(result)
 
 
 
-#Auxiliary functions
+async def describe_garment(image):
 
-@app.post("/describeGarment", summary="Describe a garment or garments in the image",
-    description="Passes the garment image to openai to describe it to improve generation of base images")
-async def describe_garment(image: UploadFile = File(...)):
-    image_bytes = await image.read()
+    print("describe garment process running")
+    image_bytes = image
     base64_image = base64.b64encode(image_bytes).decode("utf-8")
+    #print(base64_image)
 
     response = openai_client.chat.completions.create(
         model="gpt-4o",
@@ -346,7 +347,7 @@ async def describe_garment(image: UploadFile = File(...)):
             {
                 "role": "user",
                 "content": [
-                    {"type": "text", "text": "Describe this garment or garments in the image. the format should be ready to be inserted into the sentence: a man wearing ..... in front of a white background. be detailed but online describe the garments, not the rest of the images. make sure to only return the description, not the complete sentence."},
+                    {"type": "text", "text": "Describe this garment or garments in the image. the format should be ready to be inserted into the sentence: a man wearing ..... in front of a white background. describe the garments as type and fit, but not colors and design, not the rest of the images. make sure to only return the description, not the complete sentence."},
                     {
                         "type": "image_url",
                         "image_url": {
@@ -358,20 +359,29 @@ async def describe_garment(image: UploadFile = File(...)):
         ],
         max_tokens=300
     )
-
+    #print(response)
     return {"description": response.choices[0].message.content}
 
 
+async def complete_outfit(outfit_desc):
 
-@app.post("/upload")
-async def upload_files(
-    name: str = Form(...),
-    image1: UploadFile = File(...),
-    image2: UploadFile = File(None)  # Optional!
-):
-    result = {
-        "name": name,
-        "image1_filename": image1.filename,
-        "image2_filename": image2.filename if image2 else "Not provided"
-    }
-    return result
+    print("complete outfit process running")
+    current_outfit = ""
+    for description in outfit_desc:
+        print(f"description: {description['description']}")
+        current_outfit += description['description']
+
+    response = openai_client.chat.completions.create(
+        model="gpt-4o",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": f"If thie outfit is not complete (ie, it is missing a top or bottom, or a pair of pants or a pair of shoes), complete it, making sure the model is wearing a complete outfit. for the garments not already mentioned, keep it simple to not draw too much attention to those new garments. Complete this outfit description: {current_outfit}. Return only the description of the complete outfit including the current outfit, not the complete sentence in the format: blue strap top and pink skirt and white sneakers"},
+                ]
+            }
+        ],
+        max_tokens=300
+    )
+    #print(response)
+    return {"description": response.choices[0].message.content}

functions.py

@@ -4,6 +4,22 @@ from io import BytesIO
 import base64
 import uuid
 
+
+def resize_to_fit(image, max_size):
+    """
+    Resize an image to fit within max_size (width, height) while preserving aspect ratio.
+    Returns a new image with transparent background and the resized image centered.
+    """
+    image.thumbnail(max_size, Image.LANCZOS)  # Resize while keeping aspect ratio
+    new_image = Image.new("RGB", max_size, (255, 255, 255))  # white background
+    paste_position = (
+        (max_size[0] - image.width) // 2,
+        (max_size[1] - image.height) // 2,
+    )
+    new_image.paste(image, paste_position)
+    return new_image
+
+
 async def combine_images_side_by_side(image1: bytes, image2: bytes) -> str:
     """
     Takes two images, scales them to 1280x1280, combines them side by side,
@@ -25,8 +41,8 @@ async def combine_images_side_by_side(image1: bytes, image2: bytes) -> str:
     img2 = Image.open(BytesIO(image2))
     
     # Scale both images to 1280x1280
-    img1 = img1.resize((1280, 1280))
-    img2 = img2.resize((1280, 1280))
+    img1 = resize_to_fit(img1, (1280, 1280))
+    img2 = resize_to_fit(img2, (1280, 1280))
     
     # Create new image with combined width (2560) and height (1280)
     combined = Image.new('RGB', (2560, 1280))
@@ -37,7 +53,7 @@ async def combine_images_side_by_side(image1: bytes, image2: bytes) -> str:
     
     # Generate unique filename
     filename = f"tmp/combined_{uuid.uuid4()}.png"
-    
+    print("filename: " + filename)
     # Save image
     combined.save(filename)
     
@@ -46,7 +62,7 @@ async def combine_images_side_by_side(image1: bytes, image2: bytes) -> str:
         encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
     
     # Clean up
-    os.remove(filename)
+    #os.remove(filename)
     print("combined images side by side")
     return encoded_string
 

poses.py

@@ -0,0 +1,5 @@
+poses = [
+    "weight shifted to one leg (her right leg), causing a slight bend in the opposite hip. Her right hand is placed casually in her pocket, while her left arm hangs loosely by her side. Her torso is upright but slightly tilted with a subtle S-curve to the posture, and head is turned slightly toward the camera with a neutral, self-assured expression. One leg is straight while the other is relaxed, with both feet flat on the ground and spaced slightly apart. The overall stance is athletic, laid-back, and stylish.",
+    "stands upright in a neutral, relaxed position facing forward. Both arms hang naturally at her sides with a slight bend in the elbows. Her weight appears evenly distributed across both feet, which are flat on the ground and positioned hip-width apart. Expression is calm and direct, with shoulders relaxed and back straight. The overall stance is symmetrical, grounded, and natural.",
+"stands upright with arms crossed over  chest, projecting a confident and casual demeanor.  weight is shifted slightly to one leg ( right), while the other leg is relaxed with the foot lightly angled outward.  head is turned slightly to  left, looking off-camera with a neutral to thoughtful expression. The overall pose is relaxed yet assertive, often used in athletic or lifestyle apparel shoots to convey strength, ease, and focus.",
+]