Este instructivo explica cómo se pueden imprimir las fotos en un plotter CNC con la ayuda del software gratuito "Processing 3" disponible en

Las parcelas terminadas hacen regalos únicos … especialmente cuando se enmarcan.

Suministros:

Paso 1: Teoría

La imagen monocromática, que se muestra en la foto 1, comprende filas y filas de pequeños "píxeles" (elementos de la imagen). Cada "píxel" tiene un valor entre 0 (negro) y 255 (blanco) … un total de 256 tonos.

No es posible trazar una imagen monocromática directamente, ya que un trazador solo puede crear dos colores: negro (tinta) y blanco (sin tinta).

Las imágenes

Al trazar cada píxel con un valor superior a 128 se obtiene una imagen similar a la de la segunda foto.

Gran parte de los detalles se han perdido y la cara es apenas reconocible.

El código de Procesamiento 3 utilizado para crear esta imagen se muestra a continuación:

• // ----- Umbral simple
• umbral de int = 128;
• para (int y = 0; y <altura; y ++) {
• para (int x = 0; x <ancho; x ++) {
• ubicación int = x + y * ancho;
• valor flotante = brillo (píxeles ubicación);
• si (valor> umbral) {
• carrera (255); // dibujar pixel blanco
• punto (x, y);
• } else {
• golpe (0); // dibujar pixel negro
• punto (x, y);
• }
• }
• }

Dithering

Otro enfoque es usar el tramado donde cada píxel se compara con 128 y el término de error agregado al siguiente píxel antes de que a su vez se compare con 128.

La imagen resultante se muestra en la foto 3 y, a primera vista, se ve idéntica a la foto 1. Sin embargo, la diferencia entre estas dos fotos es que cada píxel en la foto 1 contiene uno de 256 tonos de gris, mientras que la foto 3 solo contiene blanco y negro. píxeles

Si examina esta imagen detenidamente, verá que el número promedio de píxeles "negros", por unidad de área, es cero para el blanco y 256 para el negro sólido. Nuestros ojos están promediando el número de píxeles "negros" en la imagen …

El código para esta imagen interpolada es similar al de la imagen de umbral y se muestra a continuación:

• // ----- dither unidimensional
• umbral de int = 128;
• para (int y = 0; y <altura; y ++) {
• error de flotación = 0;
• para (int x = 0; x <ancho; x ++) {
• ubicación int = x + y * ancho;
• valor flotante = brillo (píxeles ubicación) + error;
• si (valor> umbral) {
• carrera (255); // dibujar pixel blanco
• punto (x, y);
• error = valor - 255;
• } else {
• golpe (0); // dibujar pixel negro
• punto (x, y);
• error = valor;
• }
• }
• }

El siguiente paso describe el método de promedio utilizado para crear las imágenes en este instructivo.

Paso 2: Imágenes en escala de grises

Un problema con las imágenes interpoladas es que puede haber más de 100,000 píxeles negros, cada uno de los cuales llevará el mecanismo de elevación del lápiz y dañará el lápiz.

El número de operaciones de levantamiento de la pluma puede reducirse significativamente si convertimos la imagen en un "rompecabezas" electrónico con diferentes tonos de gris asociados con cada bloque. La imagen resultante, para un tamaño de muestra de 5x5 píxeles, se muestra en la foto 1 de arriba.

Cada una de las piezas electrónicas de "rompecabezas" ha sido sombreada usando "ondas sinusoidales" de diferentes amplitudes y frecuencias, como se muestra en la segunda foto.

La belleza de este método es que los puntos de "entrada" y "salida" para cada una de las piezas electrónicas de "rompecabezas" se encuentran en la misma línea horizontal, lo que significa que no se requiere una pluma de levantamiento hasta el final de la línea. El plotter está continuamente poniendo tinta …

La conspiración bidireccional, sin pluma, fue considerada pero rechazada, ya que cualquier juego mecánico en el trazador sería notable.

Generando la escala de grises

La escala de grises requerida se genera mediante una función drawSinewave (x, y, ciclos, amplitud).

Dónde:

• x = ubicación de la pantalla horizontal en píxeles
• y = ubicación vertical de la pantalla en píxeles
• ciclos = número de ciclos completos
• amplitud = la amplitud de onda sinusoidal

Para ver cómo funciona esto, compare las ondas sinusoidales en foto2 con cada uno de los números de pasos que se muestran en el siguiente código.

• // ------------------------------------
• // drawPattern
• // ------------------------------------
• void drawPattern (columna int, fila int, valor int) {
• / * Una escala de grises es un poco como una escalera … 16 pasos requieren 17 elevadores * /
• // ----- locales
• int x = column * cellWidth; // coordenada de pixel horizontal
• int y = row * cellHeight; // coordenada de pixel vertical
• interruptor (valor) {
• caso 0: drawSinewave (x, y, 1, 0.0); descanso; // step0 (blanco)
• caso 1: drawSinewave (x, y, 1, 0.0); descanso; //paso 1
• caso 2: drawSinewave (x, y, 1, 0.05); descanso; //paso 2
• caso 3: drawSinewave (x, y, 1, 0.2); descanso; //paso 3
• caso 4: drawSinewave (x, y, 1, 0.3); descanso; //etapa 4
• caso 5: drawSinewave (x, y, 1, 0.4); descanso; // paso 5
• caso 6: drawSinewave (x, y, 1, 0.6); descanso; // step6
• caso 7: drawSinewave (x, y, 1, 0.8); descanso; // paso7
• caso 8: drawSinewave (x, y, 1, 1.0); descanso; // step8 (gris medio)
• caso 9: drawSinewave (x, y, 2, 1.0; break; // step9
• caso 10: drawSinewave (x, y, 3, 1.0); descanso; // step10
• caso 11: drawSinewave (x, y, 4, 1.0); descanso; // step11
• caso 12: drawSinewave (x, y, 5, 1.0); descanso; // step12
• caso 13: drawSinewave (x, y, 6, 1.0); descanso; // step13
• caso 14: drawSinewave (x, y, 7, 1.0); descanso; // step14
• caso 15: drawSinewave (x, y, 8, 1.0); descanso; // step15 (negro)
• caso 16: drawSinewave (x, y, 8, 1.0); descanso;
• }
• }

Elegí usar ondas sinusoidales de diferentes amplitudes y frecuencias para mi escala de grises, pero no hay ninguna razón por la que no se puedan usar otros patrones. Todo lo que estamos tratando de hacer es engañar al ojo …

Un pequeño inconveniente

Un dibujo A4 puede tardar hasta 10 horas (toda la noche) para imprimir.

La razón de esto es que cada onda sinusoidal comprende una serie de líneas rectas a intervalos de 30 grados, o 12 coordenadas por ciclo. Las "celdas" de pantalla oscura tienden a tener más ciclos que las "celdas" de pantalla clara.

Por ejemplo, el negro, con 8 ciclos, genera 96 ​​coordenadas por "celda" de pantalla … por lo tanto, la velocidad de trazado lenta.

Paso 3: Software

El siguiente software debe instalarse en esta secuencia antes de poder trazar una imagen:

Procesando 3

Descargue e instale una copia de "Processing 3" de http://processing.org/download/. Este software nos permite crear la imagen g-code.

"Processing 3" es casi idéntico al IDE arduino (entorno de desarrollo integrado), excepto que la función "loop ()" se ha reemplazado por "draw ()". Algunos "primitivos" de dibujo también se han incluido en buena medida, dos de los cuales son:

• punto () … para trazar puntos de pantalla específicos
• línea () … para dibujar líneas entre dos conjuntos de coordenadas de pantalla.

Estas primitivas de dibujo nos permiten previsualizar nuestra imagen de código g antes de trazar.

processing3_terminal.pde

Descargue una copia de "processing3_terminal.pde" del Paso 2 del instructivo

Copie el contenido de este archivo en un nuevo boceto "processing3.exe" y guarde el boceto como "processing3_terminal".

La acción de guardar el boceto crea una carpeta "../Documents/Processing/processing3_terminal/" que contiene el archivo "processing3_terminal.pde".

draw_image_gcode.pde

Descargue el archivo adjunto "draw_image_gcode.pde".

Copie el contenido de "draw_image_gcode.pde" en un nuevo boceto de "processing3.exe" y guárdelo como "draw_image_gcode" sin las comillas.

La acción de guardar el boceto crea una carpeta "../Documents/Processing/draw_image_gcode/" que contiene el archivo "draw_image_gcode.pde".

images.zip

Descargue y descomprima el archivo "images.zip" adjunto. Este archivo zip contiene dos imágenes de prueba esenciales.

Copie los dos archivos de imagen, "image.jpg" y "grayscale.jpg" en la carpeta "../documents/Processing/draw_image_gcode" que se creó en el paso anterior.

Creando el g-code de la imagen.

Abra y ejecute el boceto "draw_image_gcode" usando "processing3..exe".

Para ejecutar un boceto utilizando "processing3.exe", simplemente haga clic con el botón izquierdo en el botón superior izquierdo de la pantalla.

Todo va bien: debería aparecer una imagen en escala de grises en su pantalla y un archivo de código g "image.ngc" aparecerá en su carpeta "../documents/Processing/draw_image_gcode".

Ahora tenemos todo lo necesario para trazar nuestra primera imagen …

Paso 4: trazando tu imagen

Las siguientes instrucciones asumen que usted tiene un plotter compatible con Inkscape conectado a su PC.

Los plotters compatibles con Inkscape suponen que la coordenada (0,0) se encuentra en la esquina inferior izquierda. Si su imagen aparece al revés e invertida, busque el código "draw_image_gcode.pde" para cualquier línea que contenga "output.print ()" y elimine cualquier referencia a "altura".

Los trazadores Inkscape adecuados incluyen:

• http://www.instructables.com/id/CNC-Drawing-Arm/
• http: //www.instructables.com/id/CNC-Dual-Arm-Plot …
• http://www.instructables.com/id/CNC-Drum-Plotter/
• http: //www.instructables.com/id/CNC-HANGING-PLOTT …

Paso 1

Copie el archivo "image.ngc" de su carpeta ",, / / ​​Documents / Processing / draw_image_gcode /" a su carpeta "../Documents/Processing/processing3_terminal/".

Paso 2

Abra "processing3.exe" y ejecute el croquis "processing3_terminal.pde" que se encuentra en una carpeta del mismo nombre.

El menú que se muestra en la foto 1 debería aparecer en su pantalla. Si no, haz clic izquierdo en el cuadro de instrucciones gris.

Las instrucciones para corregir los errores del puerto de comunicación se detallan en

Paso 3

Siga EXACTAMENTE las instrucciones que se muestran en la captura de pantalla que se muestra en la foto 1.

T1 le permite colocar el lápiz sobre la coordenada (0,0) usando las teclas 'A', 'S', 'K' y 'L'. Presione la tecla 'E' una vez que el lápiz esté posicionado correctamente.

T2 S0.4 ajusta su imagen de manera que se ajuste a una hoja de papel A4. Las dimensiones originales del archivo "imagen, jpg" eran 467 píxeles x 620 píxeles. Al escalar estas dimensiones en un 40%, se obtiene una imagen final de 186 mm x 248 mm que cabe en una hoja de papel A4 de 290 mm x 210 mm.

Etapa 4

Haga clic con el botón derecho en el cuadro de instrucciones gris 1 y luego escriba "image.ngc" sin las comillas. Presiona la tecla enter y tu plotter debería comenzar a trabajar.

Como se mencionó, las imágenes grandes tardan mucho tiempo en trazar … Yo hago la mía durante la noche.

1 no hay cursor

Paso 5: Graficando tu segunda imagen

Para trazar otra imagen, di "escala de grises.jpg", necesitamos cambiar algunas líneas de código. Estos cambios de código se muestran a continuación en negrita realce.

Es esencial que las dimensiones dentro de "tamaño"coincide con las dimensiones de su imagen.

Los "Ancho de celda", y"salida"nombre de archivo, no son críticos.

• // -------------------------------------
• // declaraciones
• // -------------------------------------
• Imagen de src; // declarar variables de tipo PImage
• Salida de PrintWriter; // instanciar "salida" para imprimir archivos
• int cellWidth = 64, // ancho de celda en píxeles … determina el detalle
• // int cellWidth = 5, // ancho de celda en píxeles … determina el detalle
• cellHeight = cellWidth, // make cell square
• columnas
• filas
• boolean penUp = true; //bandera
• // -------------------------------------
• // preparar
• // -------------------------------------
• configuración vacía () {
• tamaño (1024, 512); //gáscula de escala.jpg dimensiones (cellWidth = 64)
• // tamaño (467, 620); //imagen.jpg dimensiones (cellWidth = 5)
• fondo (255); // fondo de la imagen de pantalla blanco
• filas = altura / cellHeight; // número de filas de celdas
• columnas = ancho / ancho de celda; // número de columnas de celdas
• src = loadImage ("grayscale.jpg"); // obtener en escala de grises.jpg
• // src = loadImage ("image.jpg"); // obtener imagen.jpg
• filtro src. (gris); // convertir imagen a monocromo
• output = createWriter ("grayscale.ngc"); // abrir un archivo para almacenar el código g
• // output = createWriter ("image.ngc"); // abrir un archivo para almacenar el código g
• noLoop (); // el bucle principal solo se ejecuta una vez
• }

Haga clic aquí para ver mis otros instructables.