A medida que pasa el tiempo, el campo de las colecciones digitales se vuelve cada vez más candente. Cuando se vendió un avatar cryptopunk a Visa por $ 150,000, la gente gradualmente conoció NFT a través de varios canales.
metodología
El enfoque detrás de este generador es simple. Crea un avatar único combinando diferentes rasgos.
obtener sus datos
usetech-llcUtilizará "Substrapunks "datos del repositorio de .
Descargue su repositorio en el enlace a continuación y extraiga el archivo zip en su computadora local.
https://github.com/usetech-llc/substrapunks/archive/refs/heads/master.zippaquete de importación
Utilizará los siguientes paquetes en este proyecto:
PIL
IPython
aleatorio
json
sistema operativo
from PIL import Image
from IPython.display import display
import random
import json
import osEspecifica la rareza de las propiedades NFT
Cada avatar único se compone de cinco características.
Rostro
Orejas
Cabello
Boca
Nariz
La rareza importa porque crea escasez, que a su vez crea valor. Lograrás la rareza en una función asignando pesos a los diferentes tipos en una función. La suma de los pesos siempre debe ser 100.
Hay dos tipos de rostros (blanco y negro). Puede estipular en el programa que una imagen tiene un 60% de posibilidades de obtener una cara blanca y un 40% de posibilidades de obtener una cara negra.
# Each image is made up a series of traits
# The weightings for each trait drive the rarity and add up to 100%
face = ["White", "Black"]
face_weights = [60, 40]
ears = ["No Earring", "Left Earring", "Right Earring", "Two Earrings"]
ears_weights = [25, 30, 44, 1]
eyes = ["Regular", "Small", "Rayban", "Hipster", "Focused"]
eyes_weights = [70, 10, 5 , 1 , 14]
hair = ['Up Hair', 'Down Hair', 'Mohawk', 'Red Mohawk', 'Orange Hair', 'Bubble Hair', 'Emo Hair',
'Thin Hair',
'Bald',
'Blonde Hair',
'Caret Hair',
'Pony Tails']
hair_weights = [10 , 10 , 10 , 10 ,10, 10, 10 ,10 ,10, 7 , 1 , 2]
mouth = ['Black Lipstick', 'Red Lipstick', 'Big Smile', 'Smile', 'Teeth Smile', 'Purple Lipstick']
mouth_weights = [10, 10,50, 10,15, 5]
nose = ['Nose', 'Nose Ring']
nose_weights = [90, 10]Categorizar características
El diccionario se utiliza para redirigir los nombres de las funciones a sus nombres de archivo. Puede encontrar los nombres de los archivos de las firmas en:
...\substrapunks-master\scripts\face_parts\ 。El nombre de propiedad "Blanco" se dirige a cara1 y "Negro" se dirige a cara2.
#Classify traits
face_files = {
"White": "face1",
"Black": "face2"
}
ears_files = {
"No Earring": "ears1",
"Left Earring": "ears2",
"Right Earring": "ears3",
"Two Earrings": "ears4"
}
eyes_files = {
"Regular": "eyes1",
"Small": "eyes2",
"Rayban": "eyes3",
"Hipster": "eyes4",
"Focused": "eyes5"
}
hair_files = {
"Up Hair": "hair1",
"Down Hair": "hair2",
"Mohawk": "hair3",
"Red Mohawk": "hair4",
"Orange Hair": "hair5",
"Bubble Hair": "hair6",
"Emo Hair": "hair7",
"Thin Hair": "hair8",
"Bald": "hair9",
"Blonde Hair": "hair10",
"Caret Hair": "hair11",
"Pony Tails": "hair12"
}
mouth_files = {
"Black Lipstick": "m1",
"Red Lipstick": "m2",
"Big Smile": "m3",
"Smile": "m4",
"Teeth Smile": "m5",
"Purple Lipstick": "m6"
}
nose_files = {
"Nose": "n1",
"Nose Ring": "n2"
}definir las propiedades de la imagen
Cada avatar que creará será una combinación de seis imágenes: cara, nariz, boca, orejas y ojos.
Por lo tanto, puede escribir un ciclo for para combinar estas características en una imagen y especificar el número total de imágenes.
Una función crea un diccionario para cada imagen especificando qué características tiene.
Estas características se dan en términos de random.choice()la función .
Esta función itera sobre la lista de características de la cara (blanco, negro) y devuelve blanco (60 % de probabilidad) o negro (40 % de probabilidad).
## Generate Traits
TOTAL_IMAGES = 100 # Number of random unique images we want to generate
all_images = []
# A recursive function to generate unique image combinations
def create_new_image():
new_image = {} #
# For each trait category, select a random trait based on the weightings
new_image ["Face"] = random.choices(face, face_weights)[0]
new_image ["Ears"] = random.choices(ears, ears_weights)[0]
new_image ["Eyes"] = random.choices(eyes, eyes_weights)[0]
new_image ["Hair"] = random.choices(hair, hair_weights)[0]
new_image ["Mouth"] = random.choices(mouth, mouth_weights)[0]
new_image ["Nose"] = random.choices(nose, nose_weights)[0]
if new_image in all_images:
return create_new_image()
else:
return new_image
# Generate the unique combinations based on trait weightings
for i in range(TOTAL_IMAGES):
new_trait_image = create_new_image()
all_images.append(new_trait_image)Verificar singularidad
Para los proyectos de avatar de NFT, es importante que cada avatar sea único. Por lo tanto, es necesario verificar si todas las imágenes son únicas. Escriba una función simple que recorra todas las imágenes, las almacene en una lista y devuelva la imagen repetida.
A continuación, agregue un identificador único a cada imagen.
# Returns true if all images are unique
def all_images_unique(all_images):
seen = list()
return not any(i in seen or seen.append(i) for i in all_images)
print("Are all images unique?", all_images_unique(all_images))
# Add token Id to each image
i = 0
for item in all_images:
item["tokenId"] = i
i = i + 1
print(all_images)recuento de rasgos
Las características se asignan de acuerdo con pesos predeterminados y una función aleatoria. Esto significa que incluso si define el peso de las caras blancas como 60, no puede tener exactamente 60 caras blancas. Para saber exactamente cuántas apariciones de cada característica, es necesario realizar un seguimiento de cuántas características están presentes en su colección de imágenes.
Para hacer esto, escribe el siguiente código.
Defina un diccionario para cada característica con sus respectivas categorías, comenzando desde 0.
Recorra las imágenes que ha creado y, si encuentra rasgos, agréguelos a sus respectivos diccionarios de rasgos.
# Get Trait Counts
face_count = {}
for item in face:
face_count[item] = 0
ears_count = {}
for item in ears:
ears_count[item] = 0
eyes_count = {}
for item in eyes:
eyes_count[item] = 0
hair_count = {}
for item in hair:
hair_count[item] = 0
mouth_count = {}
for item in mouth:
mouth_count[item] = 0
nose_count = {}
for item in nose:
nose_count[item] = 0
for image in all_images:
face_count[image["Face"]] += 1
ears_count[image["Ears"]] += 1
eyes_count[image["Eyes"]] += 1
hair_count[image["Hair"]] += 1
mouth_count[image["Mouth"]] += 1
nose_count[image["Nose"]] += 1
print(face_count)
print(ears_count)
print(eyes_count)
print(hair_count)
print(mouth_count)
print(nose_count)generar imagen
Esta es la parte más asombrosa. Para cada imagen, el script hará lo siguiente.
Abra el archivo de características de la imagen donde definimos el rasgo.
Utilice el paquete PIL para seleccionar la imagen de rasgo correspondiente en su directorio.
Combinar todos los rasgos en una sola imagen
Convierte a RGB, el modelo de color más tradicional
Guarda esto en tu computadora
#### Generate Images
os.mkdir(f'./images')
for item in all_images:
im1 = Image.open(f'./scripts/face_parts/face/{face_files[item["Face"]]}.png').convert('RGBA')
im2 = Image.open(f'./scripts/face_parts/eyes/{eyes_files[item["Eyes"]]}.png').convert('RGBA')
im3 = Image.open(f'./scripts/face_parts/ears/{ears_files[item["Ears"]]}.png').convert('RGBA')
im4 = Image.open(f'./scripts/face_parts/hair/{hair_files[item["Hair"]]}.png').convert('RGBA')
im5 = Image.open(f'./scripts/face_parts/mouth/{mouth_files[item["Mouth"]]}.png').convert('RGBA')
im6 = Image.open(f'./scripts/face_parts/nose/{nose_files[item["Nose"]]}.png').convert('RGBA')
#Create each composite
com1 = Image.alpha_composite(im1, im2)
com2 = Image.alpha_composite(com1, im3)
com3 = Image.alpha_composite(com2, im4)
com4 = Image.alpha_composite(com3, im5)
com5 = Image.alpha_composite(com4, im6)
#Convert to RGB
rgb_im = com5.convert('RGB')
file_name = str(item["tokenId"]) + ".png"
rgb_im.save("./images/" + file_name)
-Haga clic a continuación para leer el texto original para unirse a los miembros de la comunidad-