jueves, 11 de diciembre de 2025

Cómo crear un icono .icns para tu app en macOS usando solo Terminal

 macOS • Iconos personalizados PRO

Convierte un PNG del Escritorio (por ejemplo el icono de QRSCAN) en un icono .icns profesional para tus apps de macOS.

Vamos a usar solo herramientas nativas: sips para generar los tamaños y iconutil para crear el .icns final.

1. Requisitos previos

  • Un Mac con macOS (Intel o Apple Silicon).
  • Un archivo PNG cuadrado en el Escritorio, por ejemplo qrscan.png, idealmente 1024x1024 px.
  • Terminal (Zsh por defecto).
Puedes adaptar el nombre del archivo (por ejemplo miapp.png), pero en los ejemplos usaremos qrscan.png.

2. Crear la carpeta de iconos (.iconset)

Primero creamos la carpeta donde irán todas las versiones de tamaño del icono:

 TERMINAL MAC
cd ~/Desktop
mkdir qrscan.iconset
Si tu PNG no se llama qrscan.png, cambia el nombre en los comandos de esta guía.

3. Generar todos los tamaños de icono con sips

macOS usa distintos tamaños de icono según el contexto (Dock, Finder, vista previa…). Vamos a generarlos todos a partir de tu PNG original.

Ejecuta este bloque tal cual (asegúrate de estar en el Escritorio):

 TERMINAL MAC
cd ~/Desktop

sips -z 16 16   qrscan.png --out qrscan.iconset/icon_16x16.png
sips -z 32 32   qrscan.png --out qrscan.iconset/icon_16x16@2x.png

sips -z 32 32   qrscan.png --out qrscan.iconset/icon_32x32.png
sips -z 64 64   qrscan.png --out qrscan.iconset/icon_32x32@2x.png

sips -z 128 128 qrscan.png --out qrscan.iconset/icon_128x128.png
sips -z 256 256 qrscan.png --out qrscan.iconset/icon_128x128@2x.png

sips -z 256 256 qrscan.png --out qrscan.iconset/icon_256x256.png
sips -z 512 512 qrscan.png --out qrscan.iconset/icon_256x256@2x.png

sips -z 512 512 qrscan.png --out qrscan.iconset/icon_512x512.png
cp qrscan.png qrscan.iconset/icon_512x512@2x.png
Si partes de un PNG de 1024x1024 px, las versiones @2x (retina) se verán nítidas en todos los tamaños.

4. Convertir la carpeta .iconset en un .icns

Ahora empaquetamos la carpeta qrscan.iconset en un único archivo qrscan.icns, que es el formato de iconos oficial de macOS.

 TERMINAL MAC
cd ~/Desktop
iconutil -c icns qrscan.iconset

Si no hay errores, tendrás en tu Escritorio un archivo llamado qrscan.icns.

Puedes eliminar la carpeta qrscan.iconset si ya no la necesitas, dejando solo el .icns.

5. Aplicar el icono .icns a una app (Automator, utilidades, etc.)

Para apps sencillas (Automator, herramientas internas), el truco más simple sigue siendo usar Vista Previa y la ventana de “Obtener información”.

  1. Haz doble clic en qrscan.icns para abrirlo con Vista Previa.
  2. En Vista Previa, ve a Edición → Seleccionar todo (o ⌘A).
  3. Después, ve a Edición → Copiar (o ⌘C).
  4. En Finder, localiza tu app (por ejemplo Leer QR.app).
  5. Haz clic derecho sobre la app y selecciona Obtener información (o pulsa ⌘I).
  6. En la ventana de información, haz clic una vez sobre el pequeño icono de arriba a la izquierda (junto al nombre de la app) hasta que quede resaltado.
  7. Pulsa ⌘V para pegar el icono .icns que tienes en el portapapeles.
El nuevo icono se propagará al Dock, Spotlight y Finder. Si no lo ves al momento, cierra y vuelve a abrir la app, o reinicia sesión.

6. Resumen

  • Partes de un PNG cuadrado en el Escritorio (qrscan.png).
  • Generas todos los tamaños en una carpeta .iconset con sips.
  • Creas un .icns profesional con iconutil.
  • Aplicás el icono a cualquier app usando Vista Previa + “Obtener información”.

Perfecto para dar identidad visual a utilidades como QRSCAN, lanzadores de scripts y apps internas de tu ecosistema macOS.

Cómo crear QRSCAN en tu Mac para leer códigos QR en PDF, JPG y PNG

 macOS • QRSCAN Profesional

Convierte tu Mac en un lector de códigos QR profesional usando Python, un entorno virtual aislado y un comando rápido llamado qrscan.

1. Requisitos previos

Solo necesitas tres cosas:

  • macOS con Terminal (Intel o Apple Silicon).
  • Python 3 preinstalado (todos los Mac modernos lo traen).
  • Homebrew instalado.

Comprueba todo con:

 TERMINAL
python3 --version
brew --version
Si eso aparece correcto, continúa. No necesitaremos usar pip global, así que no habrá errores.

2. Crear el entorno virtual seguro

Vamos a crear un entorno completamente aislado llamado qrscan-env:

 TERMINAL
python3 -m venv ~/qrscan-env
source ~/qrscan-env/bin/activate

Instala las dependencias dentro del entorno:

 TERMINAL
pip install opencv-python pillow pdf2image

Instala poppler con Homebrew (para leer PDF):

 TERMINAL
brew install poppler

3. Crear el script ~/leer_qr.py

Pega este script completo:

 TERMINAL
cat > ~/leer_qr.py << 'EOF'
import sys, os
from PIL import Image
import numpy as np
import cv2
from pdf2image import convert_from_path

detector = cv2.QRCodeDetector()

def leer_qr_en_imagen(ruta):
    img = Image.open(ruta).convert("RGB")
    arr = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)

    textos = []

    try:
        ok, decoded, pts, _ = detector.detectAndDecodeMulti(arr)
        if ok:
            textos += [t for t in decoded if t]
    except:
        t, _, _ = detector.detectAndDecode(arr)
        if t:
            textos.append(t)

    return textos

def leer_qr_en_pdf(ruta):
    paginas = convert_from_path(ruta, dpi=300)
    resultados = []
    for i, p in enumerate(paginas):
        t = f"/tmp/qrscan_{i}.png"
        p.save(t, "PNG")
        resultados += leer_qr_en_imagen(t)
        os.remove(t)
    return resultados

if len(sys.argv) < 2:
    print("Uso: python3 leer_qr.py archivo.pdf|jpg|png")
    sys.exit()

archivo = sys.argv[1]

if not os.path.exists(archivo):
    print("Archivo no encontrado:", archivo)
    sys.exit()

if archivo.lower().endswith(".pdf"):
    r = leer_qr_en_pdf(archivo)
else:
    r = leer_qr_en_imagen(archivo)

if not r:
    print("No se encontró ningún QR")
else:
    print("=== QR DETECTADOS ===")
    for x in r:
        print(x)
EOF

4. Crear el comando rápido qrscan

Con esto podrás leer QR desde cualquier sitio simplemente escribiendo qrscan archivo.pdf.

Crea ~/bin si no existe:

 TERMINAL
mkdir -p ~/bin

Crea el script:

 TERMINAL
cat > ~/bin/qrscan << 'EOF'
#!/bin/zsh
"$HOME/qrscan-env/bin/python" "$HOME/leer_qr.py" "$@"
EOF

chmod +x ~/bin/qrscan

Añádelo al PATH:

 TERMINAL
echo 'export PATH="$HOME/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

5. Cómo usar QRSCAN

Una vez instalado, puedes leer códigos QR de cualquier archivo PDF, JPG o PNG simplemente usando el comando qrscan.

Ejemplo con PDF:

 TERMINAL
qrscan "/ruta/a/diseño.pdf"

Ejemplo con imagen:

 TERMINAL
qrscan "/ruta/a/imagen.png"
Ten en cuenta que el proceso puede tardar unos segundos, especialmente en PDFs con varias páginas. Una vez analizado el archivo, el comando mostrará en Terminal todos los enlaces detectados dentro de los códigos QR.

6. Acción rápida en Finder: clic derecho → “Leer QR”

Vamos a crear una Acción rápida (Quick Action) que te permitirá leer códigos QR directamente desde el menú contextual del Finder: seleccionas cualquier PDF, JPG o PNG → botón derecho → Acciones rápidas → Leer QR. Es la forma más cómoda de usar QRScan en tu día a día.

6.1 Configurar la Acción rápida en Automator

  1. Abre Automator.
  2. Pulsa Nuevo documento.
  3. Selecciona Acción rápida.
  4. Configura la parte superior así:
    • El flujo de trabajo recibe: archivos o carpetas
    • En: Finder.app
    • Imagen: Acción
    • Color: Negro
  5. En la barra lateral izquierda, busca “Ejecutar script de shell” y arrástralo al flujo.
  6. Configura:
    • Shell: /bin/zsh
    • Pasar datos de entrada: como argumentos

Pega este script final, 100% funcional para PDF multipágina, JPG y PNG:

 TERMINAL MAC
export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"

PY="$HOME/qrscan-env/bin/python3"

for f in "$@"
do
  RESULT=$("$PY" "$HOME/leer_qr.py" "$f" \
    | grep -v '^=== QR DETECTADOS ===' \
    | sed '/^[[:space:]]*$/d' \
    | head -n 1)

  if [ -z "$RESULT" ]; then
    osascript -e 'display dialog "No se detectó ningún QR en el archivo seleccionado." with title "QRScan" buttons {"OK"} default button 1'
  else
    printf "%s" "$RESULT" | pbcopy

    osascript -e '
      display dialog "El contenido del QR se ha copiado al portapapeles:" & return & return & (the clipboard as text) ¬
      with title "QRScan - enlace copiado" buttons {"OK"} default button 1
    '
  fi
done

Guarda la acción con el nombre Leer QR. Ahora aparecerá automáticamente en: clic derecho → Acciones rápidas → Leer QR.

Esta acción puede tardar unos segundos en mostrar el resultado, especialmente si el archivo es un PDF multipágina o contiene varios códigos QR.
Configuración correcta de Acción rápida en Automator para QRScan

Haz clic para ampliar la imagen — configuración correcta de la Acción rápida “Leer QR”.

7. Crear una app (.app) arrastrar-y-soltar

Si quieres tener un acceso rápido en tu Dock o Escritorio, puedes crear una aplicación llamada Leer QR.app para arrastrar archivos PDF/JPG/PNG encima y obtener el enlace del QR al instante.

7.1. Crear la aplicación en Automator

Abre Automator y selecciona Aplicación como tipo de documento:

  1. Abre Automator en tu Mac.
  2. Selecciona Nuevo documento.
  3. Elige la opción Aplicación (muy importante).
  4. En la biblioteca de acciones, busca “Ejecutar un script de shell” y arrástralo al flujo.
  5. Configura así:
    • Shell: /bin/zsh
    • Pasar datos de entrada: como argumentos

Pega el siguiente script dentro del campo de Automator:

 AUTOMATOR (zsh)
for f in "$@"
do
  "$HOME/qrscan-env/bin/python" "$HOME/leer_qr.py" "$f"
done

Guarda la aplicación con el nombre Leer QR.app y colócala en Aplicaciones o en el Escritorio. Si quieres un acceso aún más rápido, arrástrala al Dock.

Ahora podrás arrastrar cualquier archivo PDF, JPG o PNG encima del icono de Leer QR.app. La app ejecutará el script y mostrará en Terminal el enlace del QR detectado.

8. Crear un Atajo de macOS (Shortcuts)

También puedes crear un atajo para leer códigos QR desde Spotlight, desde la barra de menús o incluso asignarle un atajo de teclado. Este método también usa el entorno virtual qrscan-env.

8.1. Crear un atajo que pide un archivo y lee el QR

  1. Abre la app Atajos en tu Mac.
  2. Crea un nuevo atajo llamado Leer QR (archivo).
  3. Añade la acción “Seleccionar archivo”. Esta acción permite elegir un PDF, JPG o PNG.
  4. Añade la acción “Ejecutar script de shell”. Configúrala así:
    • Shell: /bin/zsh
    • Entrada: archivo seleccionado

Pega este script dentro del bloque:

 ATAJOS (zsh)
PY="$HOME/qrscan-env/bin/python3"
"$PY" "$HOME/leer_qr.py" "$1"
Puedes añadir una acción final de Notificación para mostrar los enlaces QR o una acción para copiarlos al portapapeles. El proceso puede tardar unos segundos si el PDF es grande.

9. Resumen

Ya tienes un ecosistema completo para leer códigos QR en tu Mac:

  • qrscan — comando rápido profesional.
  • Acción rápida en Finder.
  • App arrastrar-y-soltar.
  • Atajo de macOS.