Merge branch 'dev'

.gitignore

@@ -0,0 +1,2 @@
+
+/.venv

app.py

@@ -1,146 +1,147 @@
 import gradio as gr
+import plotly.graph_objs as go
+import trimesh
 import numpy as np
-import random
-from diffusers import DiffusionPipeline
+from PIL import Image
 import torch
+from diffusers import StableDiffusionPipeline
+import os
+import matplotlib.pyplot as plt
 
+# Load the Stable Diffusion model for text-to-image generation
 device = "cuda" if torch.cuda.is_available() else "cpu"
+pipeline = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4").to(device)
 
-if torch.cuda.is_available():
-    torch.cuda.max_memory_allocated(device=device)
-    pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", torch_dtype=torch.float16, variant="fp16", use_safetensors=True)
-    pipe.enable_xformers_memory_efficient_attention()
-    pipe = pipe.to(device)
-else: 
-    pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", use_safetensors=True)
-    pipe = pipe.to(device)
-
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
-
-def infer(prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps):
-
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-        
-    generator = torch.Generator().manual_seed(seed)
-    
-    image = pipe(
-        prompt = prompt, 
-        negative_prompt = negative_prompt,
-        guidance_scale = guidance_scale, 
-        num_inference_steps = num_inference_steps, 
-        width = width, 
-        height = height,
-        generator = generator
-    ).images[0] 
-    
-    return image
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
-
-css="""
-#col-container {
-    margin: 0 auto;
-    max-width: 520px;
-}
-"""
-
-if torch.cuda.is_available():
-    power_device = "GPU"
-else:
-    power_device = "CPU"
-
-with gr.Blocks(css=css) as demo:
-    
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(f"""
-        # Text-to-Image Gradio Template
-        Currently running on {power_device}.
-        """)
-        
-        with gr.Row():
-            
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
-            
-            run_button = gr.Button("Run", scale=0)
-        
-        result = gr.Image(label="Result", show_label=False)
-
-        with gr.Accordion("Advanced Settings", open=False):
-            
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
-            
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
+# Get the current directory
+current_dir = os.getcwd()
+# Default object file path
+DEFAULT_OBJ_FILE = os.path.join(current_dir, "female.obj")
+# Temporary texture file path
+TEMP_TEXTURE_FILE = os.path.join(current_dir, "generated_texture.png")
+# File path to save the 2D image
+OUTPUT_IMAGE_FILE = os.path.join(current_dir, "output_image.png")
+DEFAULT_GLB_FILE= os.path.join(current_dir, "vroid_girl1.glb")
+
+def apply_texture(mesh, texture_file):
+    texture_image = Image.open(texture_file)
+    uv_coords = mesh.visual.uv
+    uv_coords = np.clip(uv_coords, 0, 1)
+    texture_colors = np.array([
+        texture_image.getpixel((
+            int(u * (texture_image.width - 1)),
+            int(v * (texture_image.height - 1))
+        )) for u, v in uv_coords
+    ])
+    texture_colors = texture_colors / 255.0
+    return texture_colors
+
+def display_3d_object(obj_file, texture_file, light_intensity, ambient_intensity, color):
+    file_extension = obj_file.split('.')[-1].lower()
+    if file_extension == 'obj':
+        mesh = trimesh.load(obj_file)
+    elif file_extension == 'glb':
+        mesh = load_glb_file(obj_file)
+    else:
+        raise ValueError("Unsupported file format. Please upload a .obj or .glb file.")
+
+    if texture_file:
+        colors = apply_texture(mesh, texture_file)
+    else:
+        colors = color
+
+    ambient_intensity = max(0, min(ambient_intensity, 1))
+    fig = go.Figure(data=[
+        go.Mesh3d(
+            x=mesh.vertices[:, 0],
+            y=mesh.vertices[:, 1],
+            z=mesh.vertices[:, 2],
+            i=mesh.faces[:, 0],
+            j=mesh.faces[:, 1],
+            k=mesh.faces[:, 2],
+            facecolor=colors if texture_file else None,
+            color=color if not texture_file else None,
+            opacity=0.50,
+            lighting=dict(
+                ambient=ambient_intensity,
+                diffuse=light_intensity,
+                specular=0.5,
+                roughness=0.1,
+                fresnel=0.2
+            ),
+            lightposition=dict(
+                x=100,
+                y=200,
+                z=300
             )
-            
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-            
-            with gr.Row():
-                
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=512,
-                )
-                
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=512,
-                )
-            
-            with gr.Row():
-                
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,
-                )
-                
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=12,
-                    step=1,
-                    value=2,
-                )
-        
-        gr.Examples(
-            examples = examples,
-            inputs = [prompt]
         )
+    ])
+    fig.update_layout(scene=dict(aspectmode='data'))
+
+    #Cleaning Temp file
+    if os.path.exists(TEMP_TEXTURE_FILE):
+        os.remove(TEMP_TEXTURE_FILE)
+        print(f"Deleted existing file: {TEMP_TEXTURE_FILE}")
+    else:
+        print(f"File not found: {TEMP_TEXTURE_FILE}")
+
+    return fig
+
+def load_glb_file(filename):
+    trimesh_scene = trimesh.load(filename)
+    if isinstance(trimesh_scene, trimesh.Scene):
+        mesh = trimesh_scene.dump(concatenate=True)
+    else:
+        mesh = trimesh_scene
+    return mesh
+
+def generate_clothing_image(prompt):
+    image = pipeline(prompt).images[0]
+    image.save(TEMP_TEXTURE_FILE)
+    return TEMP_TEXTURE_FILE, image
+
+def update_texture_display(prompt, texture_file):
+    if prompt:
+        texture_path, image = generate_clothing_image(prompt)
+        return image
+    elif texture_file:
+        return Image.open(texture_file)
+    return None
+
+with gr.Blocks() as demo:
+    gr.Markdown("## 3D Object Viewer with Custom Texture, Color, and Adjustable Lighting")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Texture Options")
+            prompt_input = gr.Textbox(label="Enter a Prompt to Generate Texture", placeholder="Type a prompt...")
+            generate_button = gr.Button("Generate Texture")
+            texture_file = gr.File(label="Upload Texture file (PNG or JPG, optional)", type="filepath")
+            texture_preview = gr.Image(label="Texture Preview", visible=True)
+
+            gr.Markdown("### Lighting & Color Settings")
+            light_intensity_slider = gr.Slider(minimum=0, maximum=2, step=0.1, value=0.8, label="Light Intensity")
+            ambient_intensity_slider = gr.Slider(minimum=0, maximum=1, step=0.1, value=0.5, label="Ambient Intensity")
+            color_picker = gr.ColorPicker(value="#D3D3D3", label="Object Color")
+            submit_button = gr.Button("Submit")
+            obj_file = gr.File(label="Upload OBJ or GLB file", value=DEFAULT_OBJ_FILE, type='filepath')
+
+        with gr.Column(scale=2):
+            display = gr.Plot(label="3D Viewer")
+
+    def update_display(file, texture, light_intensity, ambient_intensity, color):
+        texture_to_use = TEMP_TEXTURE_FILE if os.path.exists(TEMP_TEXTURE_FILE) else texture
+        return display_3d_object(file, texture_to_use, light_intensity, ambient_intensity, color)
+
+    submit_button.click(fn=update_display, inputs=[obj_file, texture_file, light_intensity_slider, ambient_intensity_slider, color_picker], outputs=display)
+    generate_button.click(fn=update_texture_display, inputs=[prompt_input, texture_file], outputs=texture_preview)
+    texture_file.change(fn=update_texture_display, inputs=[prompt_input, texture_file], outputs=texture_preview)
+
+    demo.load(fn=update_display, inputs=[obj_file, texture_file, light_intensity_slider, ambient_intensity_slider, color_picker], outputs=display)
 
-    run_button.click(
-        fn = infer,
-        inputs = [prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps],
-        outputs = [result]
+    gr.Examples(
+        examples=[[DEFAULT_OBJ_FILE, None],[DEFAULT_GLB_FILE, None]],
+        inputs=[obj_file, texture_file],
+        label="Example Files"
     )
 
-demo.queue().launch()
+demo.launch(debug=True)

backup/app.py

@@ -0,0 +1,146 @@
+import gradio as gr
+import numpy as np
+import random
+from diffusers import DiffusionPipeline
+import torch
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+if torch.cuda.is_available():
+    torch.cuda.max_memory_allocated(device=device)
+    pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", torch_dtype=torch.float16, variant="fp16", use_safetensors=True)
+    pipe.enable_xformers_memory_efficient_attention()
+    pipe = pipe.to(device)
+else: 
+    pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", use_safetensors=True)
+    pipe = pipe.to(device)
+
+MAX_SEED = np.iinfo(np.int32).max
+MAX_IMAGE_SIZE = 1024
+
+def infer(prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps):
+
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+        
+    generator = torch.Generator().manual_seed(seed)
+    
+    image = pipe(
+        prompt = prompt, 
+        negative_prompt = negative_prompt,
+        guidance_scale = guidance_scale, 
+        num_inference_steps = num_inference_steps, 
+        width = width, 
+        height = height,
+        generator = generator
+    ).images[0] 
+    
+    return image
+
+examples = [
+    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
+    "An astronaut riding a green horse",
+    "A delicious ceviche cheesecake slice",
+]
+
+css="""
+#col-container {
+    margin: 0 auto;
+    max-width: 520px;
+}
+"""
+
+if torch.cuda.is_available():
+    power_device = "GPU"
+else:
+    power_device = "CPU"
+
+with gr.Blocks(css=css) as demo:
+    
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown(f"""
+        # Text-to-Image Gradio Template
+        Currently running on {power_device}.
+        """)
+        
+        with gr.Row():
+            
+            prompt = gr.Text(
+                label="Prompt",
+                show_label=False,
+                max_lines=1,
+                placeholder="Enter your prompt",
+                container=False,
+            )
+            
+            run_button = gr.Button("Run", scale=0)
+        
+        result = gr.Image(label="Result", show_label=False)
+
+        with gr.Accordion("Advanced Settings", open=False):
+            
+            negative_prompt = gr.Text(
+                label="Negative prompt",
+                max_lines=1,
+                placeholder="Enter a negative prompt",
+                visible=False,
+            )
+            
+            seed = gr.Slider(
+                label="Seed",
+                minimum=0,
+                maximum=MAX_SEED,
+                step=1,
+                value=0,
+            )
+            
+            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+            
+            with gr.Row():
+                
+                width = gr.Slider(
+                    label="Width",
+                    minimum=256,
+                    maximum=MAX_IMAGE_SIZE,
+                    step=32,
+                    value=512,
+                )
+                
+                height = gr.Slider(
+                    label="Height",
+                    minimum=256,
+                    maximum=MAX_IMAGE_SIZE,
+                    step=32,
+                    value=512,
+                )
+            
+            with gr.Row():
+                
+                guidance_scale = gr.Slider(
+                    label="Guidance scale",
+                    minimum=0.0,
+                    maximum=10.0,
+                    step=0.1,
+                    value=0.0,
+                )
+                
+                num_inference_steps = gr.Slider(
+                    label="Number of inference steps",
+                    minimum=1,
+                    maximum=12,
+                    step=1,
+                    value=2,
+                )
+        
+        gr.Examples(
+            examples = examples,
+            inputs = [prompt]
+        )
+
+    run_button.click(
+        fn = infer,
+        inputs = [prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps],
+        outputs = [result]
+    )
+
+demo.queue().launch()

backup/v1/run.py

@@ -0,0 +1,187 @@
+import gradio as gr
+import plotly.graph_objs as go
+import trimesh
+import numpy as np
+from PIL import Image
+import torch
+from diffusers import StableDiffusionPipeline
+import os
+from pythreejs import *
+from IPython.display import display
+# Load the Stable Diffusion model for text-to-image generation
+device = "cuda" if torch.cuda.is_available() else "cpu"
+pipeline = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4").to(device)
+import os
+# Get the current directory
+current_dir = os.getcwd()
+# Default object file path (replaced with current directory)
+DEFAULT_OBJ_FILE = os.path.join(current_dir, "female.obj")
+# Temporary texture file path (replaced with current directory)
+TEMP_TEXTURE_FILE = os.path.join(current_dir, "generated_texture.png")
+# File path to save the 2D image (replaced with current directory)
+OUTPUT_IMAGE_FILE = os.path.join(current_dir, "output_image.png")
+DEFAULT_GLB_FILE= os.path.join(current_dir, "vroid_girl1.glb")
+
+def apply_texture(mesh, texture_file):
+    # Load the texture image
+    texture_image = Image.open(texture_file)
+
+    # Get texture coordinates and faces from the mesh
+    uv_coords = mesh.visual.uv
+
+    # Ensure UV coordinates are within the valid range
+    uv_coords = np.clip(uv_coords, 0, 1)
+
+    # Extract texture colors for each vertex
+    texture_colors = np.array([
+        texture_image.getpixel((
+            int(u * (texture_image.width - 1)),
+            int(v * (texture_image.height - 1))
+        )) for u, v in uv_coords
+    ])
+
+    # Normalize colors to be between 0 and 1
+    texture_colors = texture_colors / 255.0
+
+    return texture_colors
+
+def display_3d_object(obj_file, texture_file, light_intensity, ambient_intensity, color):
+    # Determine the file type and load accordingly
+    file_extension = obj_file.split('.')[-1].lower()
+
+    if (file_extension == 'obj'):
+        mesh = trimesh.load(obj_file)
+    elif file_extension == 'glb':
+        mesh = load_glb_file(obj_file)
+    else:
+        raise ValueError("Unsupported file format. Please upload a .obj or .glb file.")
+
+    # Apply texture if available
+    if texture_file:
+        colors = apply_texture(mesh, texture_file)
+    else:
+        colors = color
+
+    # Clamp the ambient_intensity to be between 0 and 1
+    ambient_intensity = max(0, min(ambient_intensity, 1))
+
+    # Create a 3D plot using Plotly
+    fig = go.Figure(data=[
+        go.Mesh3d(
+            x=mesh.vertices[:, 0],
+            y=mesh.vertices[:, 1],
+            z=mesh.vertices[:, 2],
+            i=mesh.faces[:, 0],
+            j=mesh.faces[:, 1],
+            k=mesh.faces[:, 2],
+            facecolor=colors if texture_file else None,
+            color=color if not texture_file else None,
+            opacity=0.50,
+            lighting=dict(
+                ambient=ambient_intensity,
+                diffuse=light_intensity,
+                specular=0.5,
+                roughness=0.1,
+                fresnel=0.2
+            ),
+            lightposition=dict(
+                x=100,
+                y=200,
+                z=300
+            )
+        )
+    ])
+
+    fig.update_layout(scene=dict(aspectmode='data'))
+
+    return fig
+
+def load_glb_file(filename):
+    # Load GLB file using trimesh
+    trimesh_scene = trimesh.load(filename)
+
+    # Extract the first mesh from the scene
+    if isinstance(trimesh_scene, trimesh.Scene):
+        mesh = trimesh_scene.dump(concatenate=True)
+    else:
+        mesh = trimesh_scene
+
+    return mesh
+
+def extract_uv_texture(obj_file):
+    # Load the 3D model
+    mesh = trimesh.load(obj_file)
+
+    # Ensure the mesh has visual/texture information
+    if mesh.visual.uv is None or len(mesh.visual.uv) == 0:
+        raise ValueError("The mesh does not have UV mapping information.")
+
+    # Extract the texture map from the mesh, if it exists
+    texture_image = None
+    if mesh.visual.material.image is not None:
+        texture_image = mesh.visual.material.image
+    else:
+        # If no texture is found, create a blank white texture
+        texture_size = 1024
+        texture_image = Image.new('RGB', (texture_size, texture_size), color=(255, 255, 255))
+
+    return texture_image
+
+def generate_clothing_image(prompt):
+    """Generate an image of clothing based on the text prompt."""
+    image = pipeline(prompt).images[0]
+    image.save(TEMP_TEXTURE_FILE)
+    return TEMP_TEXTURE_FILE, image
+
+def update_texture_display(prompt, texture_file):
+    if prompt:
+        texture_path, image = generate_clothing_image(prompt)
+        return image
+    elif texture_file:
+        return Image.open(texture_file)
+    return None
+
+with gr.Blocks() as demo:
+    gr.Markdown("## 3D Object Viewer with Custom Texture, Color, and Adjustable Lighting")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Texture Options")
+            prompt_input = gr.Textbox(label="Enter a Prompt to Generate Texture", placeholder="Type a prompt...")
+            generate_button = gr.Button("Generate Texture")
+            texture_file = gr.File(label="Upload Texture file (PNG or JPG, optional)", type="filepath")
+            texture_preview = gr.Image(label="Texture Preview", visible=True)
+
+            gr.Markdown("### Lighting & Color Settings")
+            light_intensity_slider = gr.Slider(minimum=0, maximum=2, step=0.1, value=0.8, label="Light Intensity")
+            ambient_intensity_slider = gr.Slider(minimum=0, maximum=1, step=0.1, value=0.5, label="Ambient Intensity")  # Updated the max value to 1
+            color_picker = gr.ColorPicker(value="#D3D3D3", label="Object Color")
+            submit_button = gr.Button("Submit")
+            obj_file = gr.File(label="Upload OBJ or GLB file", value=DEFAULT_OBJ_FILE, type='filepath')
+
+        with gr.Column(scale=2):
+            display = gr.Plot(label="3D Viewer")
+            extract_button = gr.Button("Extract UV Texture")
+            output_image = gr.Image(label="Extracted UV Texture", visible=True)
+
+    def update_display(file, texture, light_intensity, ambient_intensity, color):
+        texture_to_use = TEMP_TEXTURE_FILE if os.path.exists(TEMP_TEXTURE_FILE) else texture
+        return display_3d_object(file, texture_to_use, light_intensity, ambient_intensity, color)
+
+    def extract_and_display_uv_texture(file):
+        return extract_uv_texture(file)
+
+    submit_button.click(fn=update_display, inputs=[obj_file, texture_file, light_intensity_slider, ambient_intensity_slider, color_picker], outputs=display)
+    generate_button.click(fn=update_texture_display, inputs=[prompt_input, texture_file], outputs=texture_preview)
+    texture_file.change(fn=update_texture_display, inputs=[prompt_input, texture_file], outputs=texture_preview)
+    extract_button.click(fn=extract_and_display_uv_texture, inputs=[obj_file], outputs=output_image)
+
+    demo.load(fn=update_display, inputs=[obj_file, texture_file, light_intensity_slider, ambient_intensity_slider, color_picker], outputs=display)
+
+    gr.Examples(
+        examples=[[DEFAULT_OBJ_FILE, None],[DEFAULT_GLB_FILE, None]],
+        inputs=[obj_file, texture_file],
+        label="Example Files"
+    )
+
+demo.launch(debug=True)

backup/v2/run.py

@@ -0,0 +1,161 @@
+import gradio as gr
+import plotly.graph_objs as go
+import trimesh
+import numpy as np
+from PIL import Image
+import torch
+from diffusers import StableDiffusionPipeline
+import os
+import matplotlib.pyplot as plt
+
+# Load the Stable Diffusion model for text-to-image generation
+device = "cuda" if torch.cuda.is_available() else "cpu"
+pipeline = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4").to(device)
+
+# Get the current directory
+current_dir = os.getcwd()
+# Default object file path
+DEFAULT_OBJ_FILE = os.path.join(current_dir, "female.obj")
+# Temporary texture file path
+TEMP_TEXTURE_FILE = os.path.join(current_dir, "generated_texture.png")
+# File path to save the 2D image
+OUTPUT_IMAGE_FILE = os.path.join(current_dir, "output_image.png")
+DEFAULT_GLB_FILE= os.path.join(current_dir, "vroid_girl1.glb")
+
+def apply_texture(mesh, texture_file):
+    texture_image = Image.open(texture_file)
+    uv_coords = mesh.visual.uv
+    uv_coords = np.clip(uv_coords, 0, 1)
+    texture_colors = np.array([
+        texture_image.getpixel((
+            int(u * (texture_image.width - 1)),
+            int(v * (texture_image.height - 1))
+        )) for u, v in uv_coords
+    ])
+    texture_colors = texture_colors / 255.0
+    return texture_colors
+
+def display_3d_object(obj_file, texture_file, light_intensity, ambient_intensity, color):
+    file_extension = obj_file.split('.')[-1].lower()
+    if file_extension == 'obj':
+        mesh = trimesh.load(obj_file)
+    elif file_extension == 'glb':
+        mesh = load_glb_file(obj_file)
+    else:
+        raise ValueError("Unsupported file format. Please upload a .obj or .glb file.")
+
+    if texture_file:
+        colors = apply_texture(mesh, texture_file)
+    else:
+        colors = color
+
+    ambient_intensity = max(0, min(ambient_intensity, 1))
+    fig = go.Figure(data=[
+        go.Mesh3d(
+            x=mesh.vertices[:, 0],
+            y=mesh.vertices[:, 1],
+            z=mesh.vertices[:, 2],
+            i=mesh.faces[:, 0],
+            j=mesh.faces[:, 1],
+            k=mesh.faces[:, 2],
+            facecolor=colors if texture_file else None,
+            color=color if not texture_file else None,
+            opacity=0.50,
+            lighting=dict(
+                ambient=ambient_intensity,
+                diffuse=light_intensity,
+                specular=0.5,
+                roughness=0.1,
+                fresnel=0.2
+            ),
+            lightposition=dict(
+                x=100,
+                y=200,
+                z=300
+            )
+        )
+    ])
+    fig.update_layout(scene=dict(aspectmode='data'))
+    return fig
+
+def load_glb_file(filename):
+    trimesh_scene = trimesh.load(filename)
+    if isinstance(trimesh_scene, trimesh.Scene):
+        mesh = trimesh_scene.dump(concatenate=True)
+    else:
+        mesh = trimesh_scene
+    return mesh
+
+def extract_uv_texture(obj_file):
+    mesh = trimesh.load(obj_file)
+    if mesh.visual.uv is None or len(mesh.visual.uv) == 0:
+        raise ValueError("The mesh does not have UV mapping information.")
+    
+    texture_image = None
+    if mesh.visual.material.image is not None:
+        texture_image = mesh.visual.material.image
+    else:
+        texture_size = 1024
+        texture_image = Image.new('RGB', (texture_size, texture_size), color=(255, 255, 255))
+    
+    return texture_image
+
+def generate_clothing_image(prompt):
+    image = pipeline(prompt).images[0]
+    image.save(TEMP_TEXTURE_FILE)
+    return TEMP_TEXTURE_FILE, image
+
+def update_texture_display(prompt, texture_file):
+    if prompt:
+        texture_path, image = generate_clothing_image(prompt)
+        return image
+    elif texture_file:
+        return Image.open(texture_file)
+    return None
+
+with gr.Blocks() as demo:
+    gr.Markdown("## 3D Object Viewer with Custom Texture, Color, and Adjustable Lighting")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Texture Options")
+            prompt_input = gr.Textbox(label="Enter a Prompt to Generate Texture", placeholder="Type a prompt...")
+            generate_button = gr.Button("Generate Texture")
+            texture_file = gr.File(label="Upload Texture file (PNG or JPG, optional)", type="filepath")
+            texture_preview = gr.Image(label="Texture Preview", visible=True)
+
+            gr.Markdown("### Lighting & Color Settings")
+            light_intensity_slider = gr.Slider(minimum=0, maximum=2, step=0.1, value=0.8, label="Light Intensity")
+            ambient_intensity_slider = gr.Slider(minimum=0, maximum=1, step=0.1, value=0.5, label="Ambient Intensity")
+            color_picker = gr.ColorPicker(value="#D3D3D3", label="Object Color")
+            submit_button = gr.Button("Submit")
+            obj_file = gr.File(label="Upload OBJ or GLB file", value=DEFAULT_OBJ_FILE, type='filepath')
+
+        with gr.Column(scale=2):
+            display = gr.Plot(label="3D Viewer")
+            extract_button = gr.Button("Extract UV Texture")
+            output_image = gr.Image(label="Extracted UV Texture", visible=True)
+
+    def update_display(file, texture, light_intensity, ambient_intensity, color):
+        texture_to_use = TEMP_TEXTURE_FILE if os.path.exists(TEMP_TEXTURE_FILE) else texture
+        return display_3d_object(file, texture_to_use, light_intensity, ambient_intensity, color)
+
+    def extract_and_display_uv_texture(file):
+        uv_texture_image = extract_uv_texture(file)
+        uv_texture_image.save(OUTPUT_IMAGE_FILE)
+        return uv_texture_image
+
+    submit_button.click(fn=update_display, inputs=[obj_file, texture_file, light_intensity_slider, ambient_intensity_slider, color_picker], outputs=display)
+    generate_button.click(fn=update_texture_display, inputs=[prompt_input, texture_file], outputs=texture_preview)
+    texture_file.change(fn=update_texture_display, inputs=[prompt_input, texture_file], outputs=texture_preview)
+    extract_button.click(fn=extract_and_display_uv_texture, inputs=[obj_file], outputs=output_image)
+
+    demo.load(fn=update_display, inputs=[obj_file, texture_file, light_intensity_slider, ambient_intensity_slider, color_picker], outputs=display)
+
+    gr.Examples(
+        examples=[[DEFAULT_OBJ_FILE, None],[DEFAULT_GLB_FILE, None]],
+        inputs=[obj_file, texture_file],
+        label="Example Files"
+    )
+
+demo.launch(debug=True)

env.bat

@@ -0,0 +1,2 @@
+@echo off
+\.venv\Scripts\activate.bat

install.bat

@@ -0,0 +1,29 @@
+@echo off
+
+:: Check if Python 3.11 is installed
+python -V 2>&1 | findstr /I "Python 3.11" >nul
+if errorlevel 1 (
+    echo Python 3.11 is not installed. Please install it first.
+    exit /b 1
+)
+
+:: Create virtual environment named .venv using Python 3.11
+python -m venv .venv
+
+:: Activate the virtual environment
+call .venv\Scripts\activate.bat
+
+:: Install packages from requirements.txt
+if exist requirements.txt (
+    pip install -r requirements.txt
+) else (
+    echo requirements.txt not found. Installing packages directly.
+    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
+    pip install pillow  diffusers trimesh gradio pythreejs plotly
+    
+)
+
+:: Deactivate the virtual environment
+deactivate
+
+echo Environment setup completed successfully!

requirements.txt

@@ -3,4 +3,9 @@ diffusers
 invisible_watermark
 torch
 transformers
-xformers
+xformers
+pillow
+torch
+trimesh
+gradio
+pythreejs