{"id":511,"date":"2017-09-12T20:42:40","date_gmt":"2017-09-12T18:42:40","guid":{"rendered":"http:\/\/www.joanillo.org\/?p=511"},"modified":"2020-09-24T20:43:28","modified_gmt":"2020-09-24T18:43:28","slug":"script-cncstroke-mejorando-la-conversion-dxf-a-g-code-i","status":"publish","type":"post","link":"https:\/\/www.joanillo.org\/?p=511&lang=es","title":{"rendered":"script cncstroke: mejorando la conversi\u00f3n DXF a G-Code, I"},"content":{"rendered":"

\"\"<\/a>Uno de los trabajos t\u00edpicos que se hacen con la CNC<\/strong> es el retrato de personajes en formato blanco y negro. Por ejemplo, son conocidos los retratos del Che Guevara o Albert Einstein. Estos d\u00edas estoy trabajando con la imagen de Ovidi Montllor<\/strong> [1].<\/p>\n

La idea es sencilla y conocida. Importo la imagen en LibreCAD<\/strong> [2] (el software CAD que utilizo, que es open source), defino la silueta, y defino unas \u00e1reas de hatching<\/em> que seran fresades (rebajadas). Utilizo el programa dxf2gcode<\/em> [3] para exportar a G-Code, y freso todo el trabajo a una profundidad de 1.5mm. La limitaci\u00f3n que tengo es que la fresa que utilizo es de 2mm de di\u00e1metro, y esto limita la resoluci\u00f3n final que pudo alcanzar.<\/p>\n

Estoy programando un peque\u00f1o script (cncstroke<\/strong> [4]) para mejorar la resoluci\u00f3n de mis trabajos. Imaginemos por ejemplo los cabellos de Albert Einstein. Lo ideal es que las mechas de cabello acaben en punta, haciendo un trazo que pase de grueso a fino. Esto se consigue haciendo que la profundidad de ataque de la broca sea variable, desde 1.5mm de profundidad en el inicio del trazo hasta 0mm al final del trazo. Pero para que el invento funcione, no he de utilizar una broca normal, sino una broca V-Shape<\/a> (con punta de 40 grados). De esta manera conseguir\u00e9 el efecto de hacer un trazo que pase de 2mm de ancho en el origen a 0 mm en el extremo. Esta t\u00e9cnica tambi\u00e9n ser\u00e1 muy \u00fatil para fresar letras que simulen trazos variables.<\/p>\n

La idea es que en els mis proyectos de LibreCAD tendr\u00e9 una capa con la silueta b\u00e1sica (que fresar\u00e9 con una broca de 2mm), y una capa (que siempre nombrar\u00e9 stroke<\/em>) que constar\u00e1 de polil\u00edneas<\/em> que representar\u00e1n el trazo variable desde 2mm hasta a 0 mm de ancho. Con esta segunda capa podr\u00e9 hacer los detalles como cabellos o caligraf\u00eda de letras.<\/p>\n

En este primer art\u00edculo s\u00f3lo expongo la estructura de datos que me permitir\u00e1 gestionar la generaci\u00f3n del G-Code a partir del proyecto de LibreCAD. Cuando recorra (program\u00e1ticamente) el contenido de un proyecto LibreCAD (formato dxf<\/em>), tendr\u00e9 que buscar la definici\u00f3n de la capa stroke<\/em> y de los puntos que contiene. Esto es relativamente f\u00e1cil de hacer. Esta sucesi\u00f3n de puntos se pueden agrupar en polil\u00edneas, entendiendo que una polil\u00ednea es un conjunto de l\u00edneas que van empalmadas.<\/p>\n

Como el n\u00famero de poli\u00edneas es variable, y el n\u00famero de l\u00edneas que contiene una polil\u00ednea tambi\u00e9n es variable, la mejor manera de programar esta estructura con lenguaje C++ es utilizar vectores.
\n
\nstruct linia {
\n\\tint x0;
\n\\tint y0;
\n\\tint x1;
\n\\tint y1;
\n\\tdouble dist;
\n};<\/code><\/p>\n

struct polilinia {
\n\\tstd::vector \t vlinia;
\n\\tdouble dist;
\n};<\/linia>\n

<\/code>std::vector vpolilinia;\n<\/polilinia><\/code><\/p>\n

Una l\u00ednea consta de un punto origen y de un punto final (f\u00e1cilmente se podr\u00e1 calcular la longitud de esta l\u00ednea). Una polil\u00ednea consta de un conjunto de l\u00edneas, y la longitud de la polil\u00ednea ser\u00e1 la suma de les longitudes individuales.<\/p>\n

A continuaci\u00f3n mostramos el ejemplo m\u00ednimo de c\u00f3mo se pueden gestionar diferentes polil\u00edneas, cada una con un n\u00famero variable de l\u00edneas.
\n
\n\/\/ g++ -o polilinia polilinia.cpp
\n#include
\n#include
\n#include
\n#include
\n#include \n<\/math.h><\/vector><\/sstream><\/string><\/iostream><\/code><\/p>\n

struct linia {
\n\\tint x0;
\n\\tint y0;
\n\\tint x1;
\n\\tint y1;
\n\\tdouble length;
\n};<\/code><\/p>\n

struct polilinia {
\n\\tstd::vector \t vlinia;
\n\\tdouble length;
\n};<\/linia>\n

std::vector vpolilinia;<\/polilinia>\n

using namespace std;<\/p>\n

int main() {
\n\\t
\n\\tdouble lengthlinia,lengthpolilinia;
\n\\tpolilinia polilinia1;\\t
\n\\tlinia linia1;<\/p>\n

\\tlengthpolilinia=0;<\/p>\n

\\tlinia1.x0=34;
\n\\tlinia1.y0=30;
\n\\tlinia1.x1=120;
\n\\tlinia1.y1=122;
\n\\tlengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
\n\\tlinia1.length=lengthlinia;
\n\\tlengthpolilinia += lengthlinia;<\/p>\n

\\tpolilinia1.vlinia.push_back(linia1);<\/p>\n

\\tlinia1.x0=320;
\n\\tlinia1.y0=322;
\n\\tlinia1.x1=420;
\n\\tlinia1.y1=422;
\n\\tlengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
\n\\tlinia1.length=lengthlinia;
\n\\tlengthpolilinia += lengthlinia;<\/p>\n

\\tpolilinia1.vlinia.push_back(linia1);
\n\\t
\n\\tpolilinia1.length = lengthpolilinia;
\n\\t
\n\\tvpolilinia.push_back(polilinia1);
\n\\t
\n\\t\/\/cout << vpolilinia.at(0).vlinia.size() << endl;<\/p>\n

\\t\/\/anem per una altra polilinia
\n\\tpolilinia1.vlinia.clear();
\n\\tlengthpolilinia=0;<\/p>\n

\\tlinia1.x0=134;
\n\\tlinia1.y0=130;
\n\\tlinia1.x1=220;
\n\\tlinia1.y1=222;
\n\\tlengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
\n\\tlinia1.length=lengthlinia;
\n\\tlengthpolilinia += lengthlinia;<\/p>\n

\\tpolilinia1.vlinia.push_back(linia1);<\/p>\n

\\tlinia1.x0=220;
\n\\tlinia1.y0=222;
\n\\tlinia1.x1=320;
\n\\tlinia1.y1=322;
\n\\tlengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
\n\\tlinia1.length=lengthlinia;
\n\\tlengthpolilinia += lengthlinia;<\/p>\n

\\tpolilinia1.vlinia.push_back(linia1);<\/p>\n

\\tlinia1.x0=220;
\n\\tlinia1.y0=222;
\n\\tlinia1.x1=320;
\n\\tlinia1.y1=322;
\n\\tlengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
\n\\tlinia1.length=lengthlinia;
\n\\tlengthpolilinia += lengthlinia;<\/p>\n

\\tpolilinia1.vlinia.push_back(linia1);<\/p>\n

\\tpolilinia1.length = lengthpolilinia;<\/p>\n

\\tvpolilinia.push_back(polilinia1);\\t<\/p>\n

\\t\/\/cout << vpolilinia.at(1).vlinia.size() << endl;
\n\\t\/\/cout << vpolilinia.size() << endl;<\/p>\n

\\t\/\/recorrem totes les polil\u00ednies
\n\\tfor (int i=0; i
\nI la sortida per pantalla:
\n
\n$ .\/polilinia
\npolilinia #0. length: 267.358
\nlinia #0. length: 125.936
\nlinia #1. length: 141.421
\npolilinia #1. length: 408.779
\nlinia #0. length: 125.936
\nlinia #1. length: 141.421
\nlinia #2. length: 141.421
\n<\/code><\/vpolilinia.size();><\/p>\n

En el siguiente art\u00edculo<\/a> [5] se explica la implementaci\u00f3n del proyecto cncstroke<\/strong> para generar G-Code con z-depth<\/em> variable.<\/p>\n

Referencias:<\/p>\n