1. home >
  2. Large Language Artefacts >
  3. gabriel smiley

Instruction: Vous devez choisir un logiciel de prédilection et utiliser un llm pour créer un smiley dans le logicel cible.

LLM-Model: chatgpt4-o

Logiciel:

Blender

Prompt:

1.creer moi fichier json qui permet de données de caractéristiques d'un smiley faché en le décrivant sa forme à partir d'une description et exprime cela dans un fichier html

  1. ecris un script python pour blender qui interprete les meme données provenant d'un json

Code :

#### json:
            smiley faché:
                {
                  "smiley": {
                    "face": {
                      "center": {"x": 0, "y": 0},
                      "radius": 1
                    },
                    "eyes": [
                      {
                        "center": {"x": -0.33, "y": 0.33},
                        "radius": 0.167
                      },
                      {
                        "center": {"x": 0.33, "y": 0.33},
                        "radius": 0.167
                      }
                    ],
                    "eyebrows": [
                      {
                        "center": {"x": -0.33, "y": 0.6},
                        "radius": 0.2,
                        "startAngle": 135,
                        "endAngle": 45
                      },
                      {
                        "center": {"x": 0.33, "y": 0.6},
                        "radius": 0.2,
                        "startAngle": -135,
                        "endAngle": 45
                      }
                    ],
                    "mouth": {
                      "center": {"x": 0, "y": -0.33},
                      "radius": 0.5,
                      "startAngle": 180,
                      "endAngle": 0
                    }
                  }
                }

            smiley surpris:
                {
                  "head": {
                    "radius": 50,
                    "position": {"x": 0, "y": 0, "z": 0},
                    "color": "#ffcc00"
                  },
                  "eyes": [
                    {
                      "radius": 10,
                      "position": {"x": -20, "y": 20, "z": 30},
                      "color": "#ffffff"
                    },
                    {
                      "radius": 10,
                      "position": {"x": 20, "y": 20, "z": 30},
                      "color": "#ffffff"
                    }
                  ],
                  "mouth": {
                    "type": "arc",
                    "radius": 30,
                    "startAngle": 0,
                    "endAngle": 180,
                    "position": {"x": 0, "y": -30, "z": 0},
                    "color": "#cc0000"
                  }
                }

#### python for blender:
            smiley faché:

                    import bpy
                    import json
                    import math

                    ##### Charger les données JSON
                    with open('/home/monade/Bureau/workshop ia/smiley_data_blender.json', 'r') as file:
                        data = json.load(file)

                    ##### Fonction pour créer un cercle
                    def create_circle(center, radius, name):
                        bpy.ops.mesh.primitive_uv_sphere_add(radius=radius, location=(center['x'], center['y'], 0))
                        bpy.context.object.name = name

                    ##### Fonction pour créer un arc de cercle (sourcils et bouche)
                    def create_arc(center, radius, start_angle, end_angle, name):
                        bpy.ops.mesh.primitive_circle_add(radius=radius, location=(center['x'], center['y'], 0))
                        bpy.context.object.name = name
                        bpy.ops.object.mode_set(mode='EDIT')
                        bpy.ops.mesh.delete(type='VERT')
                        bpy.ops.object.mode_set(mode='OBJECT')

                        ##### Calculer les angles en radians
                        start_angle_rad = math.radians(start_angle)
                        end_angle_rad = math.radians(end_angle)

                        ##### Ajouter les vertices de l'arc
                        bpy.ops.mesh.primitive_circle_add(radius=radius, location=(center['x'], center['y'], 0), vertices=32)
                        bpy.context.object.name = name
                        bpy.ops.object.mode_set(mode='EDIT')
                        bpy.ops.mesh.delete(type='VERT')
                        bpy.ops.object.mode_set(mode='OBJECT')

                        ##### Ajouter les vertices de l'arc
                        for i in range(32):
                            angle = start_angle_rad + (end_angle_rad - start_angle_rad) * (i / 31)
                            x = center['x'] + radius * math.cos(angle)
                            y = center['y'] + radius * math.sin(angle)
                            bpy.ops.mesh.primitive_uv_sphere_add(radius=0.01, location=(x, y, 0))

                        bpy.ops.object.mode_set(mode='OBJECT')

                    ##### Créer le visage
                    face_data = data['smiley']['face']
                    create_circle(face_data['center'], face_data['radius'], 'Face')

                    ##### Créer les yeux
                    for eye_data in data['smiley']['eyes']:
                        create_circle(eye_data['center'], eye_data['radius'], 'Eye')

                    ##### Créer les sourcils
                    for eyebrow_data in data['smiley']['eyebrows']:
                        create_arc(eyebrow_data['center'], eyebrow_data['radius'], eyebrow_data['startAngle'], eyebrow_data['endAngle'], 'Eyebrow')

                    ##### Créer la bouche
                    mouth_data = data['smiley']['mouth']
                    create_arc(mouth_data['center'], mouth_data['radius'], mouth_data['startAngle'], mouth_data['endAngle'], 'Mouth')

                    #### smiley surpris:

                        import bpy
                        import json
                        import math

                        # Charger les données JSON
                        with open('/home/monade/Bureau/workshop ia/smiley_data_blender.json', 'r') as file:
                            data = json.load(file)

                        # Fonction pour créer un cercle
                        def create_circle(center, radius, name):
                            bpy.ops.mesh.primitive_uv_sphere_add(radius=radius, location=(center['x'], center['y'], 0))
                            bpy.context.object.name = name

                        # Fonction pour créer un arc de cercle (sourire)
                        def create_arc(center, radius, start_angle, end_angle, name):
                            bpy.ops.mesh.primitive_circle_add(radius=radius, location=(center['x'], center['y'], 0))
                            bpy.context.object.name = name
                            bpy.ops.object.mode_set(mode='EDIT')
                            bpy.ops.mesh.delete(type='VERT')
                            bpy.ops.object.mode_set(mode='OBJECT')

                            # Calculer les angles en radians
                            start_angle_rad = math.radians(start_angle)
                            end_angle_rad = math.radians(end_angle)

                            # Ajouter les vertices de l'arc
                            bpy.ops.mesh.primitive_circle_add(radius=radius, location=(center['x'], center['y'], 0), vertices=32)
                            bpy.context.object.name = name
                            bpy.ops.object.mode_set(mode='EDIT')
                            bpy.ops.mesh.delete(type='VERT')
                            bpy.ops.object.mode_set(mode='OBJECT')

                            # Ajouter les vertices de l'arc
                            for i in range(32):
                                angle = start_angle_rad + (end_angle_rad - start_angle_rad) * (i / 31)
                                x = center['x'] + radius * math.cos(angle)
                                y = center['y'] + radius * math.sin(angle)
                                bpy.ops.mesh.primitive_uv_sphere_add(radius=0.01, location=(x, y, 0))

                            bpy.ops.object.mode_set(mode='OBJECT')

                        # Créer le visage
                        face_data = data['smiley']['face']
                        create_circle(face_data['center'], face_data['radius'], 'Face')

                        # Créer les yeux
                        for eye_data in data['smiley']['eyes']:
                            create_circle(eye_data['center'], eye_data['radius'], 'Eye')

                        # Créer le sourire
                        smile_data = data['smile']
                        create_arc(smile_data['center'], smile_data['radius'], smile_data['startAngle'], smile_data['endAngle'], 'Smile')

Result : smiley surpris smiley triste