Tutorial de OpenScad

De Wikilibros, la colección de libros de texto de contenido libre.
Saltar a: navegación, buscar
OpenSCAD-logo.png

OpenSCAD es un software para la creación de sólidos 3D. Es un software libre y esta disponible tanto para GNU/Linux, MS Windows y Apple OS X.

MANUAL DE OPENSCAD


Sobre este manual: Este manual es una tradución del manual en ingles de http://en.wikibooks.org/wiki/OpenSCAD_User_Manual Esta traducción fue realizada por Kikai Labs (http://kikailabs.com.ar/). La versión PDF con imagenes puede ser descargada gratuitamente desde http://www.kikailabs.com.ar/documents/10180/63867/Tutorial%20openscad?version=1.0&t=1356541270686 La agradecemos que si encuentra algún error o considera que hay una mejor traducción en algun punto lo cambie en .

Datos a tener en cuenta: Las palabras y frases que están en italics o en cursiva corresponden a lo que se tipea(introduce) en el editor de openscad. Las mismas se encuentran en ingles debido a que el programa (como todos los otros programas para programar) interpreta el código en ingles. Palabras clave: Renderizado: es un término usado en jerga informática para referirse al proceso de generar una imagen desde un modelo. Escape: una secuencia de escape consiste en una barra invertida (\) seguida de uno o más caracteres específicos los cuales cumplen una determinada función antes o después de imprimir el mensaje dependiendo de dónde se colocan dentro del mensaje. La / es el escape al plano de los meta caracteres. Impresión: se refiere a mostrar una secuencia de caracteres en el programa. Escalar: en informática, un escalar es un determinado valor (que no varía todo a lo largo del programa informático), una variable, o un campo, que solamente puede tener un valor en un cierto momento String: secuencia de caracteres, o sea texto. Resetear: reiniciar, volver a 0, empezar de vuelta. Extrusión: la extrusión es un proceso utilizado para crear objetos con sección transversal definida y fija. El material se empuja o se extrae a través de un troquel de una sección transversal deseada. Las dos ventajas principales de este proceso por encima de procesos manufacturados son la habilidad para crear secciones transversales muy complejas y el trabajo con materiales que son quebradizos, porque el material solamente encuentra fuerzas de compresión y de cizallamiento.


Manual de openscad: Parte 1 Para nuestro primer modelo vamos a crear un simple 2 x 3 x 4 cuboides. En el editor de OpenSCAD, escriba la siguiente línea de comandos: Ejemplo de uso 1 - cubo simple:

cube ([2,3,4]);


Abrir un documento: Abrir uno de los muchos ejemplos que vienen con OpenSCAD (Archivo, Ejemplos, por ejemplo example002.scad). O usted puede copiar y pegar este ejemplo simple en la ventana OpenSCAD:


Ejemplo de uso 1 - example002.scad:

difference () {

cube (30, centro = true); sphere (20); }

translate ([0, 0, 30]) {

cylinder (h = 40, r = 10); }


Después de pegar el código de ejemplo y presionamos F5. A continuación, presione F5 para obtener una vista previa gráfica de lo que ha escrito. Tienes tres tipos de movimiento en el marco de vista previa: 1. Arrastre con el botón izquierdo del ratón para girar la vista. El fondo va a cambiar los valores de rotación. 2. Arrastre con un botón de traducir otra (mover) la vista. El fondo va a cambiar los valores de traducir. 3. Usa el escroler del ratón de desplazamiento para acercar y alejar. Alternativamente, puede utilizar la teclas + y -, o arrastrar con el ratón mientras presiona una tecla de mayúsculas. La línea Viewport en la parte inferior de la ventana se muestra un cambio en el valor de distancia.

Posicionando un objeto:

Ya hemos visto cómo crear un cubo simple. Nuestra próxima tarea es tratar de utilizar el comando de posicionamiento translate realizar un cubo idéntico al lado del cubo existente: Ejemplo de uso 1 - posicionar un objeto: cube([2,3,4]); translate ([3,0,0]) { cube ([2,3,4]); }


Posicionamiento OpenSCAD un objeto: -No hay punto y coma después del comando translate -Tenga en cuenta que no hay punto y coma después del comando translate. Esto es porque el comando translate refiere al objeto siguiente. Si el punto y coma no se omite, entonces el efecto de la traducción en la posición terminaría, y el cuboides segunda se coloca en la misma posición que la primera forma de cubo.

Vista de los modelos:

El modelo OpenSCAD forma de vista ofrece una variedad de opciones de visualización:

1. La vista de las superficies:

La vista de la superficie es la vista del modelo inicial que aparece cuando el código de modelo se representa por primera vez.

2.Red CGAL Sólo

La vista de cuadrícula sólo presenta sólo el "andamiaje" por debajo de la superficie. Piense en la Torre Eiffel.

2.La vista OpenCSG

Este modo de visualización utilizará la biblioteca abierta geometría sólida constructiva para generar la vista del modelo utilizando OpenGL. Si la biblioteca OpenCSG no está disponible o la tarjeta de vídeo o los controladores no son compatibles con OpenGL, esta vista se producirá ninguna salida visible.

3. La cuadrícula sólo ver.

4. El improvisado ver.

La interfaz del openscad: Formas de navegación:

El área de visualización se navega principalmente con el ratón: Arrastrar con el botón izquierdo del ratón hace girar la vista a lo largo de los ejes del área de visualización. Conserva la dirección del eje vertical . Arrastrar con el botón izquierdo del ratón cuando la tecla de mayúsculas se pulsa permite girar la vista a lo largo del eje vertical y del eje apuntando hacia el usuario. Arrastrar con el botón derecho o central permite mover el área visible. Para acercar, hay tres maneras: -con la rueda de desplazamiento. -arrastrando con el botón derecho del ratón, o scroler y la tecla shift. -las teclas + y - La rotación se puede restablecer mediante el atajo Ctrl +0. El movimiento resetearse usando el atajo Ctrl + P.

Ver configuración:

El área de visualización puede estar configurado para utilizar diferentes métodos de representación y otras opciones utilizando el menú View. La mayoría de las opciones descritas aquí están disponibles mediante los métodos abreviados también.

Modos de Renderizado: OpenCSG (F9): En el modo OpenCSG, la biblioteca OpenCSG se utiliza para generar el modelo visible. Esta biblioteca utiliza características avanzadas de OpenGL (2,0) como el tampón Z y no requiere una descripción explícita de la forma resultante - en cambio, hace un seguimiento de cómo los objetos se van a combinar. Por ejemplo, cuando se crea un hueco esférico en un cubo, lo primero hará va a ser el cubo en la tarjeta gráfica y luego va a hacer la esfera, pero en lugar de usar el tampón Z para ocultar las partes de la esfera que están cubiertos por el cubo, va a crear sólo la esfera, al combinarse resultan visualmente en un cubo con un hueco esférico. Este método produce resultados instantáneos, pero tiene bajas tasas de frames (baja velocidad para procesar los gráficos) cuando se trabaja con objetos muy convexos. Tenga en cuenta que la selección del modo OpenCSG usando F9 cambiará a la vista OpenCSG pasado generó, pero no se volverá a evaluar el código fuente. Es posible que desee utilizar la función de compilación (F5, que se encuentra en el menú Diseño) para reevaluar el código fuente, construir los objetos OpenCSG y luego cambiar a a la vista OpenCSG.

CGAL (Superficies y Grid, F10 y F11): El CGAL es un acrónimo que se refiere a la fuente abierta de Geometría Computacional Biblioteca de Algoritmos. En el modo de CGAL, la biblioteca CGAL se utiliza para calcular la creación del objeto raíz, que luego se muestra usando OpenGL simple. Este método puede que necesite un poco de tiempo cuando se utilizó por primera vez con un nuevo programa, pero luego tendrán mayores tasas de frames (mejora la velocidad para procesar los gráficos). Al igual que antes con OpenCSG, F10 y F11 activan el modo de pantalla CGAL pero no actualizan los objetos subyacentes; para ello, utilice la función de compilación y renderizado (F6, que se encuentra en el menú Diseño). Para combinar las ventajas de los dos métodos de visualización, se puede ajustar selectivamente partes de su programa en una función de renderizado y los obligan a coincidir uniformemente aun con elm modo OpenCSG habilitado.

Opciones de visualización:

Mostrar bordes (Ctrl +1): Si la opción de mostrar bordes está activada, tanto OpenCSG y el modo CGAL harán bordes, así como las caras de los objetos, en el modo CGAL se muestran incluso los vértices. En el modo de cuadrícula CGAL, esta opción no tiene efecto. Al activar esta opción se muestra la diferencia entre OpenCSG y CGAL con toda claridad: En el modo CGAL se ve un borde dibujado en todas partes en las que "pertenece", OpenCSG no mostrará bordes resultantes de las operaciones booleanas (verdadero o falso) - esto se debe a que nunca se calcularon explícitamente, pero están justo donde los recortes de un objeto Z comienza o termina.


Mostrar ejes (Show) (Ctrl +2): Si la opción Mostrar Ejes está activada, el origen del sistema de coordenadas global será indicado por un indicador de ejes ortogonales. Además, un indicador pequeño indicador de ejes con los nombres de los mismos que se muestran en la esquina inferior izquierda del área de visualización. El indicador más pequeño de ejes marca x, y, z y de color rojo, verde, azul, respectivamente.

Mostrar puntos de mira (Ctrl +3): Si la opción Mostrar puntos de mira (Crosshairs) está activada, el centro de la ventana gráfica se indicará con cuatro líneas que apuntan en la sala en direcciones diagonales del sistema de coordenadas global. Esto es útil cuando se alinea el área de visualización a un punto particular en el modelo para que lo mantenga centrado en la pantalla durante la rotación.

Animación (animation): La opción Animar añade una barra de animación al borde inferior de la pantalla. Tan pronto como FPS (frames) y los “Pasos” (steps) se establecen (valores razonables para empezar son 10 y 100, respectivamente), la hora actual se incrementa en 1/paso, x FPS de tiempo por segundo, hasta llegar a 1, cuando se vuelve a 0. Cada vez que se cambia el tiempo, el programa se vuelve a evaluar con la variable $ t ajustandolo a la hora actual.

Ver alineación (View alignment): Los elementos del menú superior, inferior, ..., Diagonal y Centro (Ctrl +4, Ctrl +5, ..., Ctrl +0, Ctrl + P) alinean la vista al sistema de coordenadas global. Arriba, Abajo, Izquierda, derecha, delante y detrás alinean en paralelo a los ejes, la opción Diagonal se alinea en diagonal, ya que está alineado cuando OpenSCAD comienza. La opción Centro pondrá el centro de coordenadas en el centro de la pantalla (pero no girará la vista). Por defecto, la vista está en modo de perspectiva, lo que significa que los objetos a distancias alejadas del espectador se verán más cortos, como es común con los ojos o cámaras. Cuando el modo de visualización se cambia a distancias perpendiculares, no dependerá de la distancias visibles de la cámara (la vista simulará una cámara en la distancia infinita con longitud focal infinita). Esto es especialmente útil en combinación con las opciones principales descritas anteriormente, esto se traducirá en una imagen 2D similar a lo que se vería en un dibujo de ingeniería.

El lenguaje OpenSCAD.

General: OpenSCAD utiliza el estilo de C + + para los comentarios:

// Este es un comentario

mytvar = 10; // El resto de la línea es un comentario.

/*

   Comentarios Multi-linea 
   permiten escribir multiples líneas.
  • /

La diferencia es que // solo permite poner un comentario por línea, y hay que ponerlo en cada línea, con /* uno se “ahorra” letras en el código.

Variables: Las variables en OpenSCAD son simplemente un nombre seguido de una expresión a través de la cual es asignada. El símbolo que permite asignar variables es el =. mivar = 5 + 4;

Strings (cadena de caracteres, ósea texto): Se deben poner si o si comillas y las barras invertidas se usan para “escapar” (\ "y \ \ respectivamente). Otros caracteres de escape especiales son saltos de línea (\ n), tabuladores (\ t) y saltos de línea (\ r). ¡NOTA! Este comportamiento es nuevo ya que OpenSCAD-2011.04. Puede actualizar los archivos antiguos utilizando el siguiente comando sed: sed 's / \ \ / \ \ \ \ /' no escaped.scad> escaped.scad Ejemplo: echo("The quick brown fox \tjumps \"over\" the lazy dog.\rThe quick brown fox.\nThe \\lazy\\ dog.");

Comandos de salida:

ECHO: "El rapido zorro marron salta" sobre "el perro perezoso. El rápido zorro marrón. El perro \ perezoso \ ". Las variables se establece en tiempo de compilación, no en tiempo de ejecución: Debido a que OpenSCAD calcula sus valores de variables mientras realiza la compilación y no en tiempo de ejecución, la asignación de la última variable se aplicará en todas partes en las que se utiliza la variable. Si uno modifica la variable x=3 y establece el valor x=5 , a partir de ese comando x va a equivaler a 5 en TODOS los casos en los que se utilice la variable. Ejemplo: / / El valor de 'a' refleja sólo el último valor ajustado a = 0; echo (a); a = 5; echo (a);

Resultado: ECHO: 5 ECHO: 5

Compilación de errores impresos. (Output). Este comportamiento sin embargo tiene como alcance a la raíz o a una llamada específica a de un módulo, lo que significa que puede volver a definir una variable en un módulo sin afectar a su valor fuera de ella. Sin embargo, todas las instancias dentro de dicha llamada se comportan como se describió anteriormente con el último valor de ajuste se utilizan en todo.

Ejemplo: p = 4; prueba (5); echo (p);

p = 6; prueba (8); echo (p);

módulo de prueba (q) { p = 2 + q; echo (p);

p = 4 + q; echo (p); } Salida ECHO: 9 ECHO: 9 ECHO: 6 ECHO: 12 ECHO: 12 ECHO: 6 Si bien esto parece ser contrario a la intuición, esto le permite hacer algunas cosas interesantes: Por ejemplo, si configura los archivos de biblioteca compartida para tener valores predeterminados definidos como variables en su nivel de raíz, cuando se incluye ese archivo en su propio código , puede "redefinir" o anular esas constantes simplemente asignando un nuevo valor a los mismos.

Obtención de puertas de entrada(input):

Ahora tenemos las variables, sería muy bueno tener la capacidad de obtener un método de entrada en lugar de establecer los valores de código. Hay algunas funciones para leer los datos de los archivos DXF, o se puede configurar una variable con el modificador-d en la línea de comandos.

Conseguir un punto desde un dibujo: Conseguir un punto es útil para la lectura de un punto de origen en una vista 2D en un dibujo técnico. La función dxf_cross leerá la intersección de dos líneas en una capa que especifique y volverá al punto de intersección. Esto significa que el punto debe ser dado con dos líneas en el archivo DXF, y no un punto. OriginPoint = dxf_cross (file = "drawing.dxf", capa = "SCAD.Origin" origen = [0, 0], la escala = 1);

Obtener un valor de dimensión:

Usted puede leer las dimensiones de un dibujo técnico. Esto puede ser útil para leer un ángulo de rotación, una altura de extrusión, o la separación entre las partes. En el dibujo, hay que crear una dimensión que no se muestra, pero si sirve como un identificador. Para leer el valor, se especifica este identificador con la siguiente secuencia de comandos: TotalWidth = dxf_dim (file = "drawing.dxf" name = "totalWidth" capa = "SCAD.Origin", origen = [0, 0], la escala = 1);


Operadores matemáticos:

Operadores aritméticos escalares:

Los operadores escalares aritméticos tienen números como operandos y producen números nuevos. + Suma - Resta

Multiplicación / División % Módulo

El "-" también se puede utilizar como operador de prefijo para números negativos.

Los operadores relacionales: Todo operador relacional toma números como operadores y produce un valor booleano (1 o 0, Verdadero o Falso). Los operadores de igualdad y no igual, también puede comparar los valores booleanos.



< Menor que <= Menor o igual que == Igual ! = No igual > = Mayor o igual que > Mayor que = Igual

Existe una diferencia entre el = solo y el == , el segundo obliga a la igualdad de strings.


Operadores lógicos:

Todos los operadores lógicos tienen como operadores a valores booleanos y producen un valor booleano.

&& Y lógico | | OR lógico (o a o b) ! NOT lógico (no)

Operadores condicionales:

El Operador :? se puede utilizar para evaluar condicionalmente una u otra expresión.

? : Operador condicional

Ejemplo dado: x> 0? "pos": "neg" el resultado será "pos" si x es mayor que cero, de lo contrario será "neg".

Operadores numéricos vectoriales:

Los operadores numéricos vectoriales toman un vector y un número como operadores y producen un nuevo vector.

Multiplicar todos los elementos del vector por número / Dividir todos los elementos del vector por número Operadores vectoriales: Los operadores vectoriales toman vectores como operadores y producen un nuevo vector.

+ Agregar elemento correcto - Restar elemento correcto

El "-" también puede ser utilizado como prefijo del operador vectorial, para definirlo como negativo.

Vector punto-producto operadoracional:

El vector de punto-producto operador toma dos vectores como operadores y produce un valor escalar

Suma de los productos elemento de vector


Multiplicación de matrices: Multiplica una matriz por un vector, un vector por la matriz y la matriz por la matriz

Matriz / vector de multiplicación


Funciones matemáticas:

Abs: Función matemática de valor absoluto. Devuelve el valor positivo de un número decimal con signo. Ejemplos de uso: abs (-5,0); abs (0); abs (8,0); Resultados: 5.0 0,0 8.0

Acos: Función matemática de arcocoseno, o la inversa, coseno.

Asin: Función matemática de arcoseno, o la inversa, seno.

Atan: Función matemática de arcotangente o la inversa, tangente. Devuelve el valor principal del arco tangente de x, expresado en grados.

Atan2 Función matemática de dos argumentos atan. Devuelve el valor principal del arco tangente de y / x, expresado en grados. Ceil: Función matemática techo.

Cos: Función matemática del coseno. Ejemplos de uso: for (i = [doce y treinta y seis]) translate ([i * 10,0,0]) cylinder (r = 5, h = cos (i * 10) * 50 +60);


OpenSCAD Función Cos

Exp: Función matemática exp. Devuelve la función de base “e” exponencial de x, que es el número e elevado a la potencia x. Floor: Función matemática floor. En: Logaritmo natural Matemática. Véase: Logaritmo natural Cos: Función mátematica cos.

for(i=[0:36])
   translate([i*10,0,0])cylinder(r=5,h=cos(i*10)*50+60);




Len: Función matemática de longitud. Devuelve la longitud de una matriz, un vector o un parámetro en cadena. Ejemplos de uso: str1 = "abcdef"; len_str1 = len (str1); echo (str1, len_str1);

a = 6; len_a = len (a); eco (a, len_a);

matriz1 = [1,2,3,4,5,6,7,8]; len_array1 = len (matriz1); echo (matriz1, len_array1);

matriz2 = 0,0, [0,1], [1,0], 1,1; len_array2 = len (matriz2); echo (matriz2, len_array2);

len_array2_2 = len (matriz2 [2]); echo (matriz2 [2], len_array2_2);

Resultados: ECHO: "abcdef", 6 ECHO: 6, undef ECHO: [1, 2, 3, 4, 5, 6, 7, 8], 8 ECHO: 0, 0, [0, 1], [1, 0], 1, 1, 4 ECHO: [1, 0], 2

Tenga en cuenta que el len () no se define cuando una simple variable se pasa como parámetro. Esta función permite (por ejemplo) el análisis de una matriz, un vector o una cadena. Ejemplos de uso: str2 = "4711"; for (i = [0: len (str2) -1]) echo (str ("digit", i +1, ":", cadena2 [i])); Resultados: ECHO: "dígito 1: 4" ECHO: "digit 2: 7" ECHO: "dígito 3: 1" ECHO: "dígito 4: 1"

Log: Logaritmo matemático.

Operaciones de búsqueda: (Puede fallar) A partir de un determinado valor-clave matriz, se puede interpolar un valor para cualquier clave mediante interpolación lineal. Parámetros: Clave: clave de búsqueda <key,value array> Claves y valores Ejemplo de uso: Se creará una especie de carta 3D hecha de cilindros de diferente altura. function get_cylinder_h(p) = lookup(p, [

               [ -200, 5 ],
               [ -50, 20 ],
               [ -20, 18 ],
               [ +80, 25 ],
               [ +150, 2 ]
       ]);

for (i = [-100:5:+100]) {
       // echo(i, get_cylinder_h(i));
       translate([ i, 0, -30 ]) cylinder(r1 = 6, r2 = 2, h = get_cylinder_h(i)*3);
}


OpenSCAD Función Lookup

Máx: Devuelve el máximo de los dos parámetros. Parámetros <a> Decimal. Decimal. Ejemplo de uso: max (3.0,5.0); max (8.0,3.0); Resultados: 5.0 8.0 Min: Devuelve el mínimo de los dos parámetros. Parámetros <a> Decimal. Decimal. Ejemplo de uso: min (3.0,5.0); min (8.0,3.0); Resultados: 3,0 3,0 Pow: Función matemática de poder. Parámetros: <base> Decimal. Base. <exponente> Decimal. Exponente. Ejemplos de uso: for (i = [0:5]) {

translate([i*25,0,0]) {
  cylinder(h = pow(2,i)*5, r=10);
  echo (i, pow(2,i));
}

}

Rands: Generador de números aleatorios. Genera un vector constante de números pseudo-aleatorios, al igual que una matriz. Cuando se genera un único número, todavía se puede obtener con variable [0] Parámetros: min-value: Valor mínimo del rango de números aleatorios. max_value: Valor máximo del rango de números aleatorios. value_count: Cantidad de números aleatorios que se expresan como un vector. seed_value (opcional) Valor de inicio para el generador de números aleatorios para obtener resultados repetibles. Ejemplos de uso: seed=42; random_vect=rands(5,15,4,seed); echo( "Random Vector: ",random_vect); sphere(r=5); for(i=[0:3]) {

rotate(360*i/4) {
  translate([10+random_vect[i],0,0])
    sphere(r=random_vect[i]/2);
}

}

Redondeo: El operador “round” devuelve la parte mayor o menor número entero, respectivamente, si la entrada numérica es positiva o negativa. En otras palabras redondea un número. Algunos ejemplos: round (x.5) = x +1. round (x.49) = x. ronda (- (x.5)) = - (x +1). ronda (- (x.49)) =-x.

round (5,4) / / -> 5 round (5,5) / / -> 6 round (5,6) / / -> 6

Signo Función matemática “signum”. Devuelve un valor unitario que extrae el signo de un valor. Parámetros <x> Decimal. Valor para encontrar el signo de. Ejemplos de uso: sign(-5.0); sign(0); sign(8.0); Resultados: -1,0 0,0 1,0

Sin: Función matemática seno. Parámetros: <grados> Decimal. Ángulo en grados.

Ejemplo de uso 1: for (i = [0:5]) {

echo(360*i/6, sin(360*i/6)*80, cos(360*i/6)*80);
 translate([sin(360*i/6)*80, cos(360*i/6)*80, 0 ])
  cylinder(h = 200, r=10);

} Ejemplo de uso 2: for(i=[0:36])

   translate([i*10,0,0])cylinder(r=5,h=sin(i*10)*50+60);





Función Sin en OpenSCAD Sqrt: Función matemática de raíz cuadrada.

Ejemplos de uso: translate([sqrt(100),0,0])sphere(100);

Tan: Función matemática tangente. Parámetros <Grados> Decimal. Ángulo en grados. Ejemplos de uso: for (i = [0:5]) {

echo(360*i/6, tan(360*i/6)*80);
 translate([tan(360*i/6)*80, 0, 0 ])
  cylinder(h = 200, r=10);

}

Funciones String:

Str: Convertir todos los argumentos en “strings” y concatenar. Ejemplos de uso: number=2; echo ("This is ",number,3," and that's it."); echo (str("This is ",number,3," and that's it.")); Resultados: ECHO: "This is ", 2, 3, " and that's it." ECHO: "This is 23 and that's it."

Sólidos básicos:

Cubo: Crea un cubo en el origen del sistema de coordenadas. Cuando el centro es verdadero el cubo se centrará en el origen, de lo contrario, se crea en el primer octante. Los nombres de los argumentos son opcionales si los argumentos se dan en el mismo orden como se especifica en los parámetros.


Parámetros: Tamaño: Decimal o 3 de valor matriz. Si sólo hay un número dado, el resultado será un cubo con lados de esa longitud. Si una matriz de valor 3 se da, entonces los valores se corresponden a las longitudes de los ejes X, Y, y Z. El valor por defecto es 1. Centro: Booleano. Esto determina la posición del objeto. Si es verdadero, objeto esté centrado en (0,0,0). De lo contrario, el cubo se coloca en el cuadrante positivo con una esquina en (0,0,0). El valor predeterminado es falso.

Ejemplos de uso: cube(size = 1, center = false); cube(size = [1,2,3], center = true);






Esfera: Crea una esfera en el origen del sistema de coordenadas. El nombre del argumento es opcional. Parámetros: R: Decimal. Este es el radio de la esfera. La resolución de la esfera se basará en el tamaño de la esfera y la fa $, fs $ y $ fn variables. -$ fa Ángulo en grados -$ fs Ángulo en mm -$ fn Resolución

Ejemplos de uso: sphere(r = 1); sphere(r = 5); sphere(r = 10);

/ / Esto va a crear una esfera de alta resolución con un radio de 2 mm esfera (2, $ fn = 100); / / También se creará una esfera de 2 mm de alta resolución pero éste / / No tiene triángulos pequeños como muchos de los polos de la esfera esfera (2, $ = fa 5, $ fs = 0,1);





Cilindro: Crea un cilindro o cono en el origen del sistema de coordenadas. Un solo radio (r) hace que un cilindro, dos diferentes radicales (r1, r2) hacen un cono. Parámetros: h Decimal. Esta es la altura del cilindro. El valor por defecto es 1.

r1 Decimal. Este es el radio del cono en el extremo inferior. El valor por defecto es 1.

r2 Decimal. Este es el radio del cono en el extremo superior. El valor por defecto es 1.

r Decimal. El radio de los dos extremos superior e inferior del cilindro. Utilice este parámetro si desea cilindro plano. El valor por defecto es 1.

Centro: Booleano. Si es verdadero va a centrar la altura del cono / cilindro alrededor del origen. El valor predeterminado es falso, colocando la base de la radio del cilindro o cono r1 en el origen.

$ fa Ángulo en grados $ fs Ángulo en mm

Ejemplos de uso: cylinder(h = 10, r1 = 10, r2 = 20, center = false); cylinder(h = 10, r1 = 20, r2 = 10, center = true); cylinder(h = 10, r=20); cylinder(h = 10, r=20, $fs=6);





Poliedro: Crea un poliedro con una lista de puntos y una lista de triángulos. La lista de puntos esta formada todos los vértices de la figura, la lista de triángulo es cómo los puntos se relacionan a las superficies del poliedro. Parámetros: Puntos: Vector de puntos o vértices (cada vector de 3).

Triángulos: Vector de tripletes de puntos (cada vector un número 3). Cada número es el número de punto 0-indexado a partir del vector punto. Convexidad: Entero. El parámetro de convexidad especifica el número máximo de los lados frontales (back sides) un rayo que intersecta al objeto y lo podría penetrar. Este parámetro sólo es necesario para visualizar correctamente el objeto en OpenCSG y modo de vista previa y no tiene efecto sobre la presentación del poliedro. Sintaxis de ejemplo: polyhedron(points = [ [x, y, z], ... ], triangles = [ [p1, p2, p3..], ... ], convexity = N);

Puntos del triángulo pedido: al mirar la cara de afuera hacia adentro, los puntos deben ser en sentido horario. Puede cambiar el orden de los puntos o el orden en que se mencionan en cada uno de triángulo triple. El orden de los triángulos es inmaterial. Tenga en cuenta que si los polígonos no están orientadas de la misma manera OpenSCAD no imprimirá un error o un accidente por completo, así que preste atención al orden de los vértices. Ejemplo, una pirámide de base cuadrada: polyhedron(

 points=[ [10,10,0],[10,-10,0],[-10,-10,0],[-10,10,0], // the four points at base
          [0,0,10]  ],                                 // the apex point 
 triangles=[ [0,1,4],[1,2,4],[2,3,4],[3,0,4],          // each triangle side
             [1,0,3],[2,1,3] ]                         // two triangles for square base
);






Orden de los puntos del triángulo. Un ejemplo de un poliedro más complejo, y la muestra de cómo solucionar poliedros con polígonos mal orientados. Cuando se selecciona 'Thrown together' desde el menú de la vista y se compila el diseño (no compilar y hacer!), Verá una vista previa con los polígonos mal orientadas resaltados. Lamentablemente esto no es posible destacar en el modo de vista previa OpenCSG porque interferiría con la forma en que se implementó el modo de vista previa OpenCSG.) A continuación, puedes ver el código y la imagen de un poliedro problemático.

// Poliedro malo polyhedron

   (points = [
              [0, -10, 60], [0, 10, 60], [0, 10, 0], [0, -10, 0], [60, -10, 60], [60, 10, 60], 
              [10, -10, 50], [10, 10, 50], [10, 10, 30], [10, -10, 30], [30, -10, 50], [30, 10, 50]
              ], 
    triangles = [
                 [0,2,3],   [0,1,2],  [0,4,5],  [0,5,1],   [5,4,2],  [2,4,3],
                 [6,8,9],  [6,7,8],  [6,10,11], [6,11,7], [10,8,11],
                 [10,9,8], [0,3,9],  [9,0,6], [10,6, 0],  [0,4,10],
                 [3,9,10], [3,10,4], [1,7,11],  [1,11,5], [1,7,8],  
                 [1,8,2],  [2,8,11], [2,11,5]
                 ]
    );

polyhedron

   (points = [
              [0, -10, 60], [0, 10, 60], [0, 10, 0], [0, -10, 0], [60, -10, 60], [60, 10, 60], 
              [10, -10, 50], [10, 10, 50], [10, 10, 30], [10, -10, 30], [30, -10, 50], [30, 10, 50]
              ], 
    triangles = [
                 [0,3,2],  [0,2,1],  [4,0,5],  [5,0,1],  [5,2,4],  [4,2,3],
                 [6,8,9],  [6,7,8],  [6,10,11],[6,11,7], [10,8,11],
                 [10,9,8], [3,0,9],  [9,0,6],  [10,6, 0],[0,4,10],
                 [3,9,10], [3,10,4], [1,7,11], [1,11,5], [1,8,7],  
                 [2,8,1],  [8,2,11], [5,11,2]
                 ]
    );








Consejo para principiantes: Si no entiende realmente la "orientación", trate de identificar los triángulos rosados mal orientados y luego permutar las referencias a los vectores de puntos hasta que lo haga bien. Por ejemplo en el ejemplo anterior, el tercer triángulo ([0,4,5]) era erróneo y lo fija como [4,0,5]. Además, puede seleccionar "Mostrar bordes" en el "Menú Ver", imprimir una captura de pantalla y numerar ambos puntos del triángulo. En nuestro ejemplo, los puntos son anotados en negro y los triángulos en azul. Girar el objeto alrededor y hacer una segunda copia de la parte de atrás si es necesario. De esta manera usted puede realizar un seguimiento. Técnica en sentido horario: La orientación se determina mediante la indexación de las agujas del reloj. Esto significa que si usted está buscando en el triángulo (en este caso [4,0,5]) desde el exterior verá que el camino es hacia la derecha por el centro de la cara. La orden de creación [4,0,5] es en sentido horario y por lo tanto correcta. La orden de creación [0,4,5] es hacia la izquierda y por lo tanto incorrecta. Asimismo, cualquier otra orden en sentido de las agujas del reloj [4,0,5] obras: [5,4,0] y [0,5,4] también están bien. Si se utiliza la técnica de las agujas del reloj, usted siempre tendrá sus caras exteriores (fuera de OpenSCAD, otros programas lo usan en sentido antihorario como el exterior sin embargo). Piense en ello como una regla de la mano izquierda: Si mantiene el triángulo y los dedos de su mano enrollados del mismo orden que los puntos, entonces su pulgar apunta hacia afuera.







Descripción breve de un "Poliedro"

  • Los puntos definen todos los puntos / vértices en la figura.
  • Triángulos es una lista de triángulos que se conectan hacia arriba los puntos / vértices.

Cada punto, en la lista de puntos, se define con una posición de 3- tuple x,y,z especifica. Los puntos en la lista de puntos se les asigna automáticamente un identificador a partir de cero para el uso en la lista de triángulo (0,1,2,3, ... etc). Cada triángulo, en la lista de triángulo, se define mediante la selección de 3 de sus puntos (usando el identificador de puntos) fuera de la lista de puntos. Por ejemplo estos triángulos = 0,1,2 define un triángulo desde el primer punto (los puntos se hace referencia cero) para el segundo punto y luego al tercer punto. Al examinar cualquier triángulo desde el exterior, el triángulo debe listar sus 3 puntos en el orden de las agujas del reloj.


Transformaciones:

Escala (scale): Permite escalar los elementos secundarios utilizando el vector especificado. El nombre del argumento es opcional. Ejemplo: scale(v = [x, y, z]) { ... }

Girar: Permite girar objetos unos grados alrededor del origen del sistema de coordenadas o alrededor de un eje arbitrario. Los nombres de los argumentos son opcionales, si los argumentos se presentan en el mismo orden que se especificó anteriormente (x,y,z). Cuando se especifica una rotación de ejes múltiples el modo en que la rotación se aplica es en el siguiente orden: x, y, z.

Ejemplo: rotate(a = deg, v = [x, y, z]) { ... }

Por ejemplo, para voltear un objeto al revés, puede hacer lo siguiente: rotate(a=[0,180,0]) { ... }

El ejemplo de arriba va girar el objeto 180 grados alrededor del eje “y”. El argumento opcional “v”le permite definir un eje arbitrario en el que el objeto se girará. Ejemplo con origen arbitrario. rotate(a=45, v=[1,1,0]) { ... }

Este ejemplo se gira el objeto 45 grados alrededor del eje definido por el vector [1,1,0].

Traducir (translate): Traduce (mueve) sus elementos secundarios a lo largo del vector especificado. El nombre del argumento es opcional. Ejemplo: translate(v = [x, y, z]) { ... }

Espejo(mirror): Refleja el elemento secundario en un plano que pasa por el origen. El argumento para duplicar () es el vector normal a dicho plano. Ejemplo: mirror([ 0, 1, 0 ]) { ... }

Multmatrix: Multiplica la geometría de los elementos secundarios con la matriz de transformación dada 4x4. multmatrix(m = [...]) { ... } Ejemplo (se traduce por [10, 20, 30]): multmatrix(m = [ [1, 0, 0, 10],

                [0, 1, 0, 20],
                [0, 0, 1, 30],
                [0, 0, 0,  1]
              ]) cylinder();

Ejemplo (gira 45 grados en el plano XY y se traduce por [10,20,30]): angle=45; multmatrix(m = [ [cos(angle), -sin(angle), 0, 10],

               [sin(angle), cos(angle), 0, 20],
               [0, 0, 1, 30],
               [0, 0, 0,  1]
             ]) union() {
  cylinder(r=10.0,h=10,center=false);
  cube(size=[10,10,10],center=false);

} Color: Muestra los elementos secundarios utilizando el especificado color RGB + valor alfa. Esto sólo se utiliza para la vista previa F5 porque CGAL y STL (F6) no admiten actualmente color. El valor alfa por defecto es 1,0 (opaco) si no se especifica. Ejemplo: color([r, g, b, a]) { ... }

Tenga en cuenta que el b r, g,, unos valores están limitados a valores de tipo float(enteros) en el intervalo {0,0 ... 1,0} en lugar de los números enteros más tradicionales {0 ... 255}. Sin embargo, puede especificar los valores como fracciones, por ejemplo, para R, G, B en los números enteros {0 ... 255} se puede utilizar:

color([ R/255, G/255, B/255 ]) { ... }

A partir de la versión 2011,12, los colores también se pueden elegir por su nombre. Por ejemplo, para crear una esfera roja, puede utilizar este código:

color("red") sphere(5);

Alfa también está disponible con colores con nombre:

color("Blue",0.5) cube(5);

Los nombres de los colores disponibles son tomados de la lista del consorcio World Wide Web de color SVG. Este es un gráfico de los nombres de los colores:


Minkowski: Es un método que permite combinar objetos para lograr detalles más definidos Ejemplo de uso: Digamos que usted tiene una caja plana, y desea un borde redondeado. Hay muchas maneras de hacer esto, pero Minkowski es muy elegante. Utilice un cubo y un cilindro: $fn=50; cube([10,10,1]); cylinder(r=2,h=1);




A continuación, realice una combinación Minkowski de ellos: $fn=50; minkowski() {

cube([10,10,1]);
cylinder(r=2,h=1);

}


Cascara (hull): Al igual que el anterior es una forma de combinar objetos para crear mejores modelos. Ejemplo: hull() {

  translate([15,10,0]) circle(10);
  circle(10);
}










Funciones condicionales y de bucles(if/else/loop): For Loop: Recorre en iteración los valores de un vector o de intervalo. Reitera un proceso siempre que ciertas condiciones (definidas por el usuario) sean verdaderas. Vector versión: for (variable=<vector>) <do_something> - <variable> en español: for (variable = <rango>) <hacer mientras>-<variable> se asigna a cada valor sucesivo en el vector. Versión Rango: for (variable=<range>) <do_something> en español: for (variable = <rango>) <hacer mientras> Rango: [<start>:<end>] en español: [<inicio>: <fin>] - iteración de principio a fin inclusive. También funciona si <fin> si es más pequeño que <inicio> Rango:[<start>:<increment>:<end>] [<inicio>: <increment>: <fin>] - itera de principio a fin con el incremento dado. El incremento puede ser una fracción. Nota: El incremento se da como un valor absoluto y no puede ser negativa. Si <fin> es menor que el incremento <inicio> debe permanecer sin cambios. Advertencia: Si el incremento no es un divisor par de <fin> - <inicio>, el valor iterador para la última iteración será <fin> - (<fin> - <inicio> mod <increment>). Bucles anidados: for ( variable1 = <range or vector>, variable2 = <range or vector> ) <do something, using both variables> en español: for (variable1 = <Rango o vector>, variable2 = <Rango o vector>) <Hacer algo utilizando las variables> Los bucles pueden anidarse, al igual que en los programas normales. Una abreviatura es que ambas iteraciones se pueden dar en el mismo para la declaración. Ejemplo de uso 1 - iteración sobre un vector:

for (z = [-1, 1]) // two iterations, z = -1, z = 1 {

   translate([0, 0, z])
   cube(size = 1, center = false);

}





Ejemplo 2a - iteración sobre un rango:

for ( i = [0 : 5] ) {

   rotate( i * 360 / 6, [1, 0, 0])
   translate([0, 10, 0])
   sphere(r = 1);

}








Ejemplo 2b - iteración en un rango que especifica un incremento: / / Nota: El parámetro central en la designación de rango / / ('0 .2 'En este caso) es el “incremento por” un valor / / Advertencia: Dependiendo del valor "increment-by ', el / / Valor real final será menor que el dado. for ( i = [0 : 0.2 : 5] ) {

   rotate( i * 360 / 6, [1, 0, 0])
   translate([0, 10, 0])
   sphere(r = 1);

}

Ejemplo de uso 3 - iteración sobre un vector de vectores (rotación): for(i = [ [ 0, 0, 0],

         [ 10, 20, 300],
         [200, 40,  57],
         [ 20, 88,  57] ])

{

   rotate(i)
   cube([100, 20, 20], center = true);

}





Sintaxis 4 ejemplo - iteración sobre un vector de vectores (trasladación): for(i = [ [ 0, 0, 0],

          [10, 12, 10],
          [20, 24, 20],
          [30, 36, 30],
          [20, 48, 40],
          [10, 60, 50] ])

{

   translate(i)
   cube([50, 15, 10], center = true);

}


Ejemplo de bucle anidado: for (xpos=[0:3], ypos = [0,2,6]) // do four iterations, using the 3 values of the vector

  translate([xpos, ypos, 0]) cube([0.5, 0.5, 0.5]);






Intersección bucle For: Recorre en iteración los valores de un vector o rango y toma una intersección de los contenidos. Nota: intersection_for () es un trabajo que gira a causa de un problema que no puede obtener los resultados esperados utilizando una combinación de la norma para las declaraciones for () e intersection(). Parámetros: <loop variable name> en español: <nombre de la variable del bucle> Nombre de la variable a utilizar dentro del bucle for. Ejemplo de uso 1 - bucle en un rango de: intersection_for(n = [1 : 6]) {

   rotate([0, 0, n * 60])
   {
       translate([5,0,0])
       sphere(r=12);
   }

}





Sintaxis 2 ejemplo de rotación:

intersection_for(i = [ [  0,  0,   0],
                       [ 10, 20, 300],
                       [200, 40,  57],
                       [ 20, 88,  57] ])

{

   rotate(i)
   cube([100, 20, 20], center = true);

}


Si (if): Condicionalmente evalua un sub-árbol. Evalua algo y realiza un proceso segun el resultado de esa evalución. Parámetros: Es una expresión booleana, se debe utilizar como condición. Ejemplo de uso: if (x > y) {

   cube(size = 1, center = false);

} else {

   cube(size = 2, center = true);

}

Asignar Declaración: Establezca las variables para un nuevo valor para un sub-árbol. Parámetros: Las variables que deben ser (re-) asignado Ejemplo de uso: for (i = [10:50]) {

   assign (angle = i*360/20, distance = i*10, r = i*2)
   {
       rotate(angle, [1, 0, 0])
       translate([0, distance, 0])
       sphere(r = r);
   }

}


Modelado CSG: Unión: Crea una unión de todos sus nodos secundarios. Esta es la suma de todos los objetos. Ejemplo de uso: union() {

       cylinder (h = 4, r=1, center = true, $fn=100);
       rotate ([90,0,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);

}




Diferencia: Resta la 2 ª foma (y todo el resto de la forma) los nodos secundarios de la primera forma.

Ejemplo: difference() {

       cylinder (h = 4, r=1, center = true, $fn=100);
       rotate ([90,0,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);

}





Intersección: Crea la intersección de todos los nodos secundarios. Esto mantiene la parte de superposición.

Ejemplo: intersection() {

       cylinder (h = 4, r=1, center = true, $fn=100);
       rotate ([90,0,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);

}





Renderizar: Siempre calcula el modelo de CSG para esta estructura (incluso en OpenCSG modo de vista previa). El parámetro convexidad especifica el número máximo de los lados frontales (back lados) un rayo que intersecta el objeto al que podría penetrar. Este parámetro sólo es necesario para visualizar correctamente el objeto en OpenCSG modo de vista previa y no tiene efecto sobre el resultado final del objeto.

Ejemplo: render(convexity = 1) { ... }


Cárcteres de modificación: Modificador del fondo. Esto sirve para determinar un fondo.

Ejemplo:

difference() {

       // start objects
       cylinder (h = 4, r=1, center = true, $fn=100);
       // first object that will subtracted
       % rotate ([90,0,0]) cylinder (h = 4, r=0.3, center = true, $fn=100);
       // second object that will be subtracted
       % rotate ([0,90,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);

}




Modificador de depuraración: Utilice este subárbol como de costumbre en el proceso de representación, sino también dibujar sin modificar en rosa transparente.

difference() {

       // start objects
       cylinder (h = 4, r=1, center = true, $fn=100);
       // first object that will subtracted
       # rotate ([90,0,0]) cylinder (h = 4, r=0.3, center = true, $fn=100);
       // second object that will be subtracted
       # rotate ([0,90,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);

}



Modificador de la raíz(root): Ignora el resto del diseño y el uso de este subárbol como root diseño. Ejemplo:

! { ... }

Desactivar Modificador: Haga caso omiso de este subárbol completo.

  • { ... }

Modulos: Define su propio módulo (más o menos comparable a una macro o una función en otros idiomas) es una poderosa manera de reutilizar los procedimientos. module hole(distance, rot, size) {

   rotate(a = rot, v = [1, 0, 0]) {
       translate([0, distance, 0]) {
           cylinder(r = size, h = 100, center = true);
       }
   }

}

En este ejemplo, pasando por los parámetros de distancia, rooteo y tamaño le permiten volver a utilizar esta función varias veces, salvando muchas líneas de código y la presentación de su programa será mucho más fácil de leer. Usted puede crear una instancia del módulo y pasar valores (o fórmulas) para los parámetros al igual que una llamada a la función C: hole(0, 90, 10);

Los nodos secundarios de la creación de instancias del módulo se pueden acceder mediante el child () declaración en el módulo: module lineup(num, space) {

 for (i = [0 : num-1])
   translate([ space*i, 0, 0 ]) child(0);

}

lineup(5, 65) sphere(30);

Si usted necesita para hacer su módulo iterar sobre todos los “child” ,tendrá que hacer uso de la variable $ child, por ejemplo: module elongate() {

 for (i = [0 : $children-1])
   scale([10 , 1, 1 ]) child(i);

}

elongate() { sphere(30); cube([10,10,10]); cylinder(r=10,h=50); }

Se pueden especificar valores predeterminados para los argumentos: module house(roof="flat",paint=[255,0,0]){

 color(paint)
 if(roof=="flat"){
   translate([0,-1,0])
   cube();
 } else if(roof=="pitched"){
   rotate([90,0,0])
   linear_extrude(height=1)
   polygon(points=[[0,0],[0,1],[0.5,1.5],[1,1],[1,0]],paths=[ [0,1,2,3,4] ]);
 } else if(roof=="domical"){
   translate([0,-1,0])
   union(){
     translate([0.5,0.5,1]) sphere(r=0.5,$fn=20);
     cube();   
   }
 }

}

Y a continuación, utilice uno de los siguientes métodos para proporcionar los argumentos: union(){

 house();
 translate([2,0,0]) house("pitched");
 translate([4,0,0]) house("domical",[0,255,0]);
 translate([6,0,0]) house(roof="pitched",paint=[0,0,255]);
 translate([8,0,0]) house(paint=[0,0,0],roof="pitched");
 translate([10,0,0]) house(roof="domical");
 translate([12,0,0]) house(paint=[0,128,128]);

}

Declaraciónes de inclusión: Para incluir código desde archivos externos en OpenSCAD, hay dos comandos disponibles: Incluyen el comando <filename> como si el contenido del archivo incluido se escribiera en el archivo incluido, y permite utilizar importaciones <filename> módulos y funciones, pero no ejecuta ningún comando que no sean esas definiciones. Los archivos de biblioteca se buscan en la misma carpeta que desde el diseño donde esta abierto, o en la carpeta de la biblioteca de la instalación OpenSCAD. Puede utilizar una ruta de acceso relativa a cualquiera de los dos. Si ellos están en otra parte debe dar la ruta completa. Una serie de archivos de biblioteca se incluyen en la instalación. Un archivo de biblioteca para la generación de los anillos podría tener este aspecto (que define una función y proporciona un ejemplo): ring.scad: module ring(r1, r2, h) {

   difference() {
       cylinder(r = r1, h = h);
       translate([ 0, 0, -1 ]) cylinder(r = r2, h = h+2);
   }

}

ring(5, 4, 10);

Incluyendo la biblioteca utilizando: include <ring.scad>; rotate([90, 0, 0]) ring(10, 1, 1);

resultaría en el anillo de ejemplo que se muestra, además de girar el anillo, pero: use <ring.scad>; rotate([90, 0, 0]) ring(10, 1, 1);

sólo muestra el anillo girado.


Características de otros lenguajes:

Las variables especiales: Todas las variables que empiezan con un "$" son variables especiales. La semántica es similar a las variables especiales en LISP: tienen dinámica en lugar de un ámbito léxico. $ fa, fs $ y $ fn: La $fa, $fs y $fn son variables especiales que controlan el número de facetas utilizadas para generar un arco: $ fa es el ángulo mínimo de un fragmento. Incluso un enorme círculo no tiene más de 360 fragmentos dividido por este número. El valor predeterminado es 12 (es decir, 30 fragmentos de un círculo completo). El valor mínimo permitido es de 0,01. Cualquier intento de establecer un valor más bajo causará una advertencia. $ fs es el tamaño mínimo de un fragmento. Debido a esta variable círculos muy pequeños tienen un menor número de fragmentos que los especificados usando $ fa. El valor predeterminado es 2. El valor mínimo permitido es de 0,01. Cualquier intento de establecer un valor más bajo causará una advertencia. $ fn suele ser 0. Cuando esta variable tiene un valor mayor que cero, las otras dos variables son ignoradas y el círculo completo se representa utilizando este número de fragmentos. El valor predeterminado es 0. Cuando $fa y $ fs se utilizan para determinar el número de fragmentos de un círculo, entonces OpenSCAD nunca usará menos de 5 fragmentos. Este es el código C que calcula el número de fragmentos en un círculo:

 int get_fragments_from_r(double r, double fn, double fs, double fa)
     {
             if (fn > 0.0)
                     return (int)fn;
             return (int)ceil(fmax(fmin(360.0 / fa, r*2*M_PI / fs), 5));
     }

Las esferas son primero cortadas en rebanadas, tantas como el número de fragmentos que se utilizan para representar un círculo de radio de la esfera, y luego cada rebanada se representa en tantos fragmentos como se necesiten para segmentar el radio. Es posible que usted haya reconocido ya que el polo de la esfera es por lo general un pentágono. Esto es por qué. El número de fragmentos de un cilindro se determina utilizando el mayor de los dos radios. El método también se utiliza al representar círculos y arcos de archivos DXF. Puede generar ámbitos de alta resolución al restablecer los valores $ FX en el módulo de instancia:

$fs = 0.01;
     sphere(2);

o simplemente pasando la variable especial como parámetro:

sphere(2, $fs = 0.01);

Usted puede incluso escalar la variable especial en lugar de resetearla cero: sphere(2, $fs = $fs * 0.01);

$t: La variable $ t se utiliza para la animación. Si se habilita el marco de la animación con view-> animar y dar un valor para "FPS" y "Pasos", el campo "Tiempo" muestra el valor actual de $ t. Con esta información en mente, usted puede animar su diseño. El diseño se vuelve a compilar cada 1 / "FPS" segundos y $ t aumenta en 1 / "Pasos" los "Pasos" de los tiempos, terminando en cualquiera de los dos t = $ 1 o $ t = 1-1/steps. Si "Pictures" Dump está activada, las imágenes se crearán en el mismo directorio que el archivo de scad, utilizando los siguientes valores $ t, y se guarda en los siguientes archivos.: $t=0/Steps filename="frame00001.png" $t=1/Steps filename="frame00002.png $t=2/Steps filename="frame00003.png" . . . $t=1-3/Steps filename="frame<Steps-2>.png" $t=1-2/Steps filename="frame<Steps-1>.png" $t=1-1/Steps filename="frame00000.png" O bien, para otros valores de los pasos, se sigue este patrón: $t=0/Steps filename="frame00001.png" $t=1/Steps filename="frame00002.png $t=2/Steps filename="frame00003.png" . . . $t=1-3/Steps filename="frame<Steps-2>.png" $t=1-2/Steps filename="frame<Steps-1>.png" $t=1-1/Steps filename="frame<Steps-0>.png" $t=1-0/Steps filename="frame00000.png"


El patrón que se eligío parece ser un impredecible, pero una coherente, función de a pasos. Por ejemplo, cuando Pasos(steps) = 4, se sigue el primer patrón, y da salida a un total de 4 archivos. Cuando Pasos = 3, se deduce el segundo patrón, y también genera 4 archivos. Siempre será salida, ya sea Pasos o Pasos + 1 archivos, aunque puede que no sea tan previsible. Cuando haya terminado, se envolverá alrededor y recrear cada uno de los archivos, a través de un bucle y volver a crearlos en un bucle infinito.

$ vpr y $ vpt: Estos contienen los viewport actuales de rotación y traslación - en el momento de hacer el render. Mover la ventana no la actualiza. Durante una animación se actualizanen cada frame. $ vpr muestra la rotación. $ vpt muestra la traducción (es decir, no se verán afectados por rotación y zoom) No es posible escribir en ellos y por lo tanto tampoco se pueden cambiar los parámetros del visor (aunque eso podría ser una idea bastante buena). Ejemplo:

cube([10,10,$vpr[0]/10]);

Lo que produce que cambie de tamaño en el cubo basado en el ángulo de visión, si un bucle de animación está activo (que no necesita usar la variable $ t) También puede hacer que los bits de un modelo complejo se desvanescan a medida que cambia la vista. El comando de menú Edición - Pegar Viewport rotación / traslación copia el valor actual de la ventana, pero no la actual $vpt o $vpd.

Funciones definidas por el usuario: Permite definir una función para mejorar la legibilidad del código y la reutilización. Ejemplos de uso: my_d=20; function r_from_dia(my_d) = my_d / 2; echo("Diameter ", my_d, " is radius ", r_from_dia(my_d));

Declaraciones Echo: Esta función imprime el contenido de la ventana de compilación. Útil para depurar código. Ejemplos de uso: my_h=50; my_r=100; echo("This is a cylinder with h=", my_h, " and r=", my_r); cylinder(h=my_h, r=my_r);

Render: Fuerza la generación de una malla incluso en el modo de previsualización. Es útil cuando las operaciones booleanas son demasiado lentos para realizar el seguimiento. Necesidades descripción. Ejemplos de uso: render(convexity = 2) difference() {

cube([20, 20, 150], center = true);
translate([-10, -10, 0])
 cylinder(h = 80, r = 10, center = true);
translate([-10, -10, +40])
 sphere(r = 10);
translate([-10, -10, -40])
 sphere(r = 10);

}

Superficie Ejemplo 1: //surface.scad surface(file = "surface.dat", center = true, convexity = 5); %translate([0,0,5])cube([10,10,10], center =true);

  1. surface.dat

10 9 8 7 6 5 5 5 5 5 9 8 7 6 6 4 3 2 1 0 8 7 6 6 4 3 2 1 0 0 7 6 6 4 3 2 1 0 0 0 6 6 4 3 2 1 1 0 0 0 6 6 3 2 1 1 1 0 0 0 6 6 2 1 1 1 1 0 0 0 6 6 1 0 0 0 0 0 0 0 3 1 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 0

Resultado:




Ejemplo 2: // example010.dat generated using octave:

// d = (sin(1:0.2:10)' * cos(1:0.2:10)) * 10;
// save("example010.dat", "d");
intersection() {
  surface(file = "example010.dat", center = true, convexity = 5);
  rotate(45, [0, 0, 1]) surface(file = "example010.dat", center = true, convexity = 5); 
}






Buscar: Uso del patrón:

"search" "(" ( match_value | list_of_match_values ) "," vector_of_vectors
      ("," num_returns_per_match
        ("," index_col_num )? )?
      ")";
match_value : ( Value::NUMBER | Value::STRING );
list_of_values : "[" match_value ("," match_value)* "]";
vector_of_vectors : "[" ("[" Value ("," Value)* "]")+ "]";
num_returns_per_match : int;
index_col_num : int;

Los siguientes son algunos ejemplos de uso. Los valores del índice regresan como lista Ejemplo 1: search("a","abcdabcd"); Devuelve: [0,4]

Ejemplo 2:

search("a","abcdabcd",1);

Devuelve: [0]

Ejemplo 3: search("e","abcdabcd",1); Devuelve: []

Ejemplo 4:

search("a",[ ["a",1],["b",2],["c",3],["d",4],["a",5],["b",6],["c",7],["d",8],["e",9] ]);

Devuelve:

[0,4]

Buscar en otra columna, los valores de retorno de indexación:

Ejemplo 5:

search(3,[ ["a",1],["b",2],["c",3],["d",4],["a",5],["b",6],["c",7],["d",8],["e",3] ], 0, 1);

Devuelve: 0,4,[1,5],2,6

Buscar en la lista de valores: Ejemplo 6: Devuelve todos los elementos relacionados con elemento de búsqueda vector: search("abc",[ ["a",1],["b",2],["c",3],["d",4],["a",5],["b",6],["c",7],["d",8],["e",9] ], 0); Devuelve: 0,4,[1,5],2,6

Ejemplo 7: Regreso primer partido por elemento de búsqueda vector, vector especial de regreso caso: search("abc",[ ["a",1],["b",2],["c",3],["d",4],["a",5],["b",6],["c",7],["d",8],["e",9] ], 1); Devuelve: [0,1,2]

Ejemplo 8: Mostrar los primeros dos partidos por elemento de búsqueda vector, vector de vectores: search("abce",[ ["a",1],["b",2],["c",3],["d",4],["a",5],["b",6],["c",7],["d",8],["e",9] ], 2); Devuelve: 0,4,[1,5],[2,6],8

Buscar en la lista de strings: Ejemplo 9:

lTable2=[ ["cat",1],["b",2],["c",3],["dog",4],["a",5],["b",6],["c",7],["d",8],["e",9],["apple",10],["a",11] ];
lSearch2=["b","zzz","a","c","apple","dog"];
l2=search(lSearch2,lTable2);
echo(str("Default list string search (",lSearch2,"): ",l2));

Resultado:

ECHO: "Default list string search ([\"b\", \"zzz\", \"a\", \"c\", \"apple\", \"dog\"]): [1, [], 4, 2, 9, 3]"


Utilizando el susbsistema 2D. 2D básico: Todas las primitivas 2D pueden ser transformadas al formato 3D. Normalmente se utiliza como parte de una extrusión 3D. Aunque son muy delgadas, se representan con un espesor de 1. Cuadrado: Crea un cuadrado en el origen del sistema de coordenadas.Cuando la función centrar sea verdadera centrará el cuadrado en el origen, de lo contrario, se crea en el primer cuadrante. Los nombres de los argumentos son opcionales, si los argumentos se dan en el mismo orden como se especifica en los parámetros. Parámetros: Tamaño Decimal o 2 matriz de Array. Si sólo hay un número dado, el resultado será un cuadrado con lados de esa longitud. Si una matriz de valor 2 se da, entonces los valores se corresponden a las longitudes de los ejes X y Y lados. El valor por defecto es 1. Centrar Booleano. Esto determina la posición del objeto. Si es verdad, objeto esté centrado en (0,0). De lo contrario, el cuadrado se coloca en el cuadrante positivo con una esquina en (0,0). El valor predeterminado es false. Ejemplo: square ([2,2],center = true);

Círculo: Crea un círculo en el origen del sistema de coordenadas. El nombre del argumento es opcional. Parámetros R: Decimal. Este es el radio del círculo. La resolución del círculo se basará en el tamaño del círculo. Si usted necesita un círculo pequeño, de alta resolución se puede evitar esto haciendo un círculo grande, entonces la ampliación debe ser utilizando un factor apropiado, o puede establecer $ fn u otras variables especiales. El valor por defecto es 1. Ejemplos: circle(); // uses default radius, r=1 circle(r = 10); scale([1/100, 1/100, 1/100]) circle(200); // this will create a high resolution circle with a 2mm radius circle(2, $fn=50); // Another way to create a high-resolution circle with a radius of 2.

Polígono: Crea un polígono con los puntos y trayectorias especificados . Parámetros: Puntos: Vector compuesto por 2 vectores de los elementos elemento, es decir, la lista de los puntos del polígono. Trayectorias: Ya sea un solo vector, la enumeración de la lista de puntos, ya sea el fin de atravesar los puntos, o, un vector de vectores, o bien una lista de listas de puntos para cada curva particular del polígono. Este último es necesario si el polígono tiene agujeros. El parámetro es opcional y si se omite, se supone que los puntos en orden (El "PN" componentes del vector de trayectorias es 0-indexado referenciando a los elementos del vector de puntos.) Convexidad: Integer. Número de curvas "hacia adentro", es decir cruces esperados de ruta de una línea a través de la arbitraty polígono. Uso: polygon(points = [ [x, y], ... ], paths = [ [p1, p2, p3..], ...], convexity = N);

Ejemplo: polygon(points=0,0,[100,0],[0,100],[10,10],[80,10],10,80, paths=0,1,2,3,4,5);






En este ejemplo, tenemos 6 puntos (tres para el "exterior" del triángulo, y tres para el "interior" de uno). Ponemos en contacto a cada uno con dos 2 trayectorias. Cada elemento de una ruta debe corresponder a la posición de un punto definido en el vector de puntos, por ejemplo, "1" se refiere a [100,0]. Aviso: Con el fin de obtener un objeto 3D, ya sea extruir un polígono 2D (lineal o (rotar) o utilice directamente el sólido primitivo poliedro. Cuando se utiliza la extrusión para formar sólidos, es importante darse cuenta de que la dirección de creación del polígono es significativa. Si un polígono se enrolla en la dirección incorrecta con respecto al eje de rotación, el sólido final (después de la extrusión) puede terminar invisible. Este problema puede ser verificado al voltear el polígono utilizando la escala ([-1,1]) (suponiendo que la extrusión se realiza alrededor del eje Z como está por defecto). Aviso: sin embargo, a diferencia de las órdenes de dibujo 2D al operar en los ejes rotulados como X e Y, la extrusión ordena implícitamente traducir estos objetos en coordenadas XZ y girar alrededor del eje Z. Ejemplo: polygon(0,0,[10,90],11,-10, convexity = N);

Import_dxf: Leer un archivo DXF y crear una forma 2D. Ejemplo: linear_extrude(height = 5, center = true, convexity = 10) import_dxf(file = "example009.dxf", layer = "plate");

Proyección de 2D a 3D. Usando la función de projection(), puede crear dibujos 2D en modelos 3D, y exportarlas al formato dxf. Funciona mediante la proyección de un modelo 3D al plano (x, y), con z en 0. Si se cut = true sólo los puntos con z = 0 se consideran (cortes efectivos del objeto), con cut = false, puntos por encima y por debajo del plano se consideran así (la creación de una proyección adecuada). Ejemplo: Considere example002.scad, que viene con OpenSCAD. Se puede cargar y representar a example002.stl (con F6). A continuación, puede cargar el archivo de nuevo en stl OpenSCAD, así: import_stl("example002.stl");




Entonces usted puede hacer un "corte" de proyección, que le da la "rebanada" del plano xy con z = 0. projection(cut = true) import_stl("example002.stl");





También se puede hacer una proyección "ordinaria" , lo que da una especie de "sombra" del objeto sobre el plano xy. projection(cut = false) import_stl("example002.stl");





¿Qué pasa si tomamos ejemplo 002 y moverlo hacia arriba, fuera del plano XY? Y gira? translate([0,0,25]) rotate([90,0,0]) import_stl("/tmp/d.stl");




Ahora, usted puede proyectar y obtener una "vista lateral" de todo el objeto. projection(cut=false) import_stl(“/full/path/to/stl”);







Extrusión lineal: La extrusión lineal es una operación de modelado que toma un polígono 2D como entrada y lo extiende en la tercera dimensión. De esta manera se crea una forma 3D. Uso: linear_extrude(height = fanwidth, center = true, convexity = 10, twist = -fanrot) {...}

(Debe utilizar nombres de parámetros debido a un problema de compatibilidad con versiones anteriores) Si falla la extrusión de una forma 2D no trival, intente ajustar el parámetro de convexidad (por defecto no es 10, pero 10 es un "buen" valor para probarlo). Twist(Giro): Twist es el número de grados a través del cual se extruye la forma. Ajuste del giro = parámetro 360° se extruye a través de una revolución. El sentido de giro sigue la regla de la mano izquierda o sentido antihorario.



Twist al 0°. linear_extrude(height = 10, center = true, convexity = 10, twist = 0) translate([2, 0, 0]) circle(r = 1);

Twist al -100°.





linear_extrude(height = 10, center = true, convexity = 10, twist = -100) translate([2, 0, 0]) circle(r = 1);





linear_extrude(height = 10, center = true, convexity = 10, twist = 100) translate([2, 0, 0]) circle(r = 1);


Twist al -500°.




linear_extrude(height = 10, center = true, convexity = 10, twist = -500) translate([2, 0, 0]) circle(r = 1);

Centrar: Centrar determina si el objeto se centra después de la extrusión, para que no se extruya hacia arriba y hacia abajo desde el centro, como se podría esperar.






center = true linear_extrude(height = 10, center = true, convexity = 10, twist = -500) translate([2, 0, 0]) circle(r = 1);




El refinamiento de malla: El parámetro slices se puede utilizar para mejorar la salida. linear_extrude(height = 10, center = false, convexity = 10, twist = 360, slices = 100) translate([2, 0, 0]) circle(r = 1);






Las variables especiales $ fn, fs y fa $ $ también se puede utilizar para mejorar el rendimiento.

linear_extrude(height = 10, center = false, convexity = 10, twist = 360, $fn = 100) translate([2, 0, 0]) circle(r = 1);

Extrusión rotativa. Una extrusión de rotación es una extrusión lineal con un toque, literalmente. Desafortunadamente, no se puede utilizar para producir una hélice para roscas de tornillo porque el contorno 2D debe ser normal al eje de rotación.

Ejemplos:





Un toroide sencillo se puede construir usando una extrución rotativa. rotate_extrude(convexity = 10) translate([2, 0, 0]) circle(r = 1, $fn = 100);

El refinamiento de la malla.






Aumentar el número de fragmentos que la forma 2D se compone de mejorará la calidad de la malla, pero lleva más tiempo. rotate_extrude(convexity = 10) translate([2, 0, 0]) circle(r = 1, $fn = 100);





El número de los fragmentos utilizados por la extrusión también se puede aumentar. rotate_extrude(convexity = 10, $fn = 100) translate([2, 0, 0]) circle(r = 1, $fn = 100);

Extrusión de un polígono: La extrusión también se puede realizar en polígonos con puntos elegidos por el usuario. Aquí se muestra un polígono simple.




rotate([90,0,0]) polygon( points=0,0,[2,1],[1,2],[1,3],[3,4],0,5 );

Aquí es el mismo polígono, rotacionalmente extruido, y con el refinamiento de la malla establecido en 200. El polígono debe tocar el eje de rotación para la extrusión del trabajo, es decir, no se puede construir una rotación de un polígono con un agujero.





rotate_extrude($fn=200) polygon( points=0,0,[2,1],[1,2],[1,3],[3,4],0,5 );

Descripción de los parámetros de extrusión: Parámetros para todos los modos de extrusión: Convexidad: Integer. El parámetro convexidad especifica el número máximo de los lados frontales (back sides) es un rayo que intersecta al objeto al que podría penetrar. Este parámetro sólo es necesario para visualizar correctamente el objeto en OpenCSG modo de vista previa y no tiene efecto sobre la prestación del poliedro.




Esta imagen muestra una forma 2D con una convexidad de 4, como se indica el rayo rojo cruza la forma 2D un máximo de 4 veces. La convexidad de una forma 3D se determina de una manera similar. Si lo establece a 10 debería funcionar bien para la mayoría de los casos. Parámetros de extrusión lineal solamente.

height The extrusion height center If true the solid will be centered after extrusion twist The extrusion twist in degrees slices Similar to special variable $fn without being passed down to the child 2D shape.


Extrusión DFX.(este texto se encuentra incompleto). Con las declaraciones de extrusión DXF es posible convertir archivos DXF 2D directamente en objetos 3D. Extrusión lineal: Con las declaraciones de extrusión DXF es posible convertir objetos 2D en objetos 3D. linear_extrude(file = "example009.dxf", layer = "fan_top",

 height = fanwidth, center = true, convexity = 10, twist = -fanrot);

Extrusión rotativa: Una extrusión rotativa es una extrusión lineal con un toque, literalmente. rotate_extrude(file = "example009.dxf", layer = "fan_side",

 origin = fan_side_center, convexity = 10);

Descripción de los parámetros de extrusión: Parámetros para todos los modos de extrusión:

file The name of the DXF file to extrude layer The name of the DXF layer to extrude convexity See 2D to 3D Extrusion origin [x,y] coordinates to use as the drawing's center, in the units specified in the DXF file scale FIXME

Parámetros de extrusión lineal sólos.

height The extrusion height center If true, extrusion is half up and half down. If false, the section is extruded up. twist The extrusion twist in degrees slices FIXME

Otros formatos 2d. En la actualidad, OpenSCAD sólo es compatible con DXF como un formato de gráficos para gráficos en 2D. Otros formatos comunes son PS / EPS y SVG. PS / EPS El programa pstoedit puede hacer converciones entre diferentes formatos de gráficos vectoriales. OpenSCAD necesita la opción -polyaslines para pasa al plugin de salida dxf para entender el archivo. Las opciones del DT-instruye pstoedit para hacer textos, que suelen ser lo que quieres si incluye texto. (Si la resolución del texto representado en términos de número de polígonos es demasiado baja, la solución más fácil es escapar los eps antes de la conversión.) pstoedit -dt -f dxf:-polyaslines infile.eps outfile.dxf

SVG pstoedit no entiende SVG, EPS, pero se puede convertir de un SVG. inkscape, un editor de SVG se puede utilizar para la conversión. inkscape -E intermediate.eps infile.svg pstoedit -dt -f dxf:-polyaslines intermediate.eps outfile.dxf

Automatización de makefile. La conversión se puede automatizar mediante el sistema de marca, para hacer eso debe poner las siguientes líneas en su Makefile:

all: my_first_file.dxf my_second_file.dxf another_file.dxf

%.eps: %.svg
       inkscape -E $@ $<

%.dxf: %.eps
       pstoedit -dt -f dxf:-polyaslines $< $@

La primera línea especifica qué archivos DXF se genera cuando se invoca a make en el directorio actual. El segundo párrafo especifica cómo convertir un archivo con extensión. Svg a un archivo con extensión. Eps, y el tercero de Eps. a Dxf.

Importar y exportar STL:

import Importa un archivo para su uso en el modelo actual OpenSCAD. Parametros: "<file name>" Una cadena que contiene la ruta de acceso al archivo de STL para incluir. Las comillas son necesarias. Ejemplo: import("example012.stl");

Notas: En la última versión de OpenSCAD, import () ahora se utiliza para importar tanto en 2D (DXF para la extrusión) y los archivos 3D (STL). import_stl: <DEPRECATED .. Utilice el comando de importación en lugar ..> Importa un archivo de STL para su uso en el modelo actual OpenSCAD Parámetros "<file name>" Una cadena que contiene la ruta de acceso al archivo de STL para incluir.Las comillas son necesarias. Convexidad: Integer. El parámetro convexidad especifica el número máximo de los lados frontales (back sides)es un rayo que intersecta el objeto podría penetrar. Este parámetro sólo es necesario para visualizar correctamente el objeto en OpenCSG modo de vista previa y no tiene efecto sobre la prestación del poliedro.

Ejemplo: import_stl("example012.stl", convexity = 5);

Exportación a STL. Para exportar su diseño, seleccione "Exportar como STL ..." desde el "diseño" del menú, a continuación, escriba un nombre de archivo en el cuadro de diálogo resultante. No se olvide de añadir la extensión ". Stl". Solución de Problemas: Después de compilar y hacer GCAL (F6), es posible ver que su diseño es simple: no. Esas son malas noticias. Vea la línea 8 en la siguiente salida de OpenSCAD 2010,02: Parsing design (AST generation)... Compiling design (CSG Tree generation)... Compilation finished. Rendering Polygon Mesh using CGAL... Number of vertices currently in CGAL cache: 732 Number of objects currently in CGAL cache: 12

  Top level object is a 3D object:
  Simple:         no
  Valid:         yes
  Vertices:       22
  Halfedges:      70
  Edges:          35
  Halffacets:     32
  Facets:         16
  Volumes:         2

Total rendering time: 0 hours, 0 minutes, 0 seconds Rendering finished.

Cuando intenta exportar este a STL obtendrá un mensaje como:

Object isn't a valid 2-manifold! Modify your design..

"Manifold" significa que es "a prueba de agua" y que no hay ningún agujero en la geometría. En un objeto válido de 2°-variedad cada arista debe conectar exactamente dos facetas. Esto significa que el programa debe ser capaz de conectarse con una cara de un objeto. Por ejemplo si se utiliza un cubo de altura 10 paraa tallar algo de una medida más amplia en otro cubo de altura 10, no está claro a qué cubo de la parte superior o inferior de la parte. Así que el pequeño cubo debe ser un poco más "larga" (o "corta"): difference() {

       // original
       cube (size = [2,2,2]);
       // object that carves out
       # translate ([0.5,0.5,-0.5]) {
           cube (size = [1,1,3]);      
       }

}





module example1() {

               cube([20, 20, 20]);
               translate([-20, -20, 0]) cube([20, 20, 20]);
               cube([50, 50, 5], center = true);
       }

module example2() {

               cube([20.1, 20.1, 20]);
               translate([-20, -20, 0]) cube([20.1, 20.1, 20]);
               cube([50, 50, 5], center = true);
       }

Otro ejemplo: module example1() {

               cube([20, 20, 20]);
               translate([-20, -20, 0]) cube([20, 20, 20]);
               cube([50, 50, 5], center = true);
       }

module example2() {

               cube([20.1, 20.1, 20]);
               translate([-20, -20, 0]) cube([20.1, 20.1, 20]);
               cube([50, 50, 5], center = true);
       }

El ejemplo1 haría así:





El módulo ejemplo1 no es válido en la 2°-variedad porque ambos cubos comparten un borde. Se tocan pero no se intersecan. Ejemplo 2 es un ejemplo de la 2°-variedad válido porque no existe una intersección. Ahora en el borde cada uno debe conectarse exactamente con dos limitaciones de facetas de 2-variedades se se cumple. Piezas que están restando deben extenderse más allá de la pieza original. Para referencia, otra situación que hace que el diseño sea no exportable es cuando dos caras que son cada uno el resultado de un toque restan. A continuación, el mensaje de error aparece. difference () {

  cube ([20,10,10]);
  translate ([10,0,0]) cube (10);

} difference () {

  cube ([20,10,10]);
  cube (10);

}

Las superficies que tocan simplemente se controlan correctamente. translate ([10,0,0]) cube (10); cube (10);


Usando OpenSCAD en un entorno de línea de comandos: OpenSCAD no sólo puede ser utilizado como una interfaz gráfica de usuario, también trata los argumentos como una línea de comandos. Su uso de la línea dice: openscad [ -o output_file [ -d deps_file ] ] \

        [ -m make_command ] [ -D var=val [..] ] filename

El uso de la versión es de OpenSCAD 30/09/2011. openscad [ { -s stl_file | -o off_file | -x dxf_file } [ -d deps_file ] ]\

        [ -m make_command ] [ -D var=val [..] ] filename

Opciones de exportación: Cuando se invoca con la opción, OpenSCAD no inicia la GUI, pero sí ejecuta el archivo dado y lo exporta al output_file en un formato que es determinado según que extensión sea la función (. Stl /. / Desactivar. Dxf,. CSG). Algunas versiones usan -s/-d/-o para determinar el formato de archivo de salida en lugar de comprobar "OpenSCAD - help". Si la opción-d se da usa con de un comando de exportación, todos los archivos accedidos mientras se realizaba la construcción de la malla están escritos en el argumento de la-d en la sintaxis de un Makefile. Constantes: Para predefinir variables, utilice la opción-D. Se puede administrar en varias ocasiones. Cada aparición de-D debe ser seguida por una asignación. A diferencia de las asignaciones normales en OpenSCAD, estas asignaciones no definen variables, si constantes, que no se pueden cambiar en el interior del programa, y por lo tanto se puede utilizar para sobrescribir los valores definidos en el programa en el momento de la exportación. Las ubicadas a la derecha puede ser arbitrarias, incluyendo expresiones OpenSCAD operaciones matemáticas y strings. Tenga en cuenta que las cadenas tienen que ir entre comillas, que tienen que ser para el shell. Para representar un modelo que toma un parámetro de calidad con el valor de "producción", hay que correr. openscad -o my_model_production.stl -D 'quality="production"' my_model.scad

Comando para crear archivos necesarios: En un complejo proceso de construcción, algunos archivos requeridos por un archivo OpenSCAD podrían no ser encontrados, pero se pueden generar, por ejemplo, si se definen en un Makefile. Si OpenSCAD se le da la opción -m make que comenzará a hacerse presente la primera vez que se intenta acceder a un archivo que falta. Ejemplo de makefile El -d y -m sólo tienen sentido juntas. (-m sin-d no van a ser consideradas las dependencias no modificadas en la construcción de las exportaciones, sin-d ,-m requeriría los archivos que se hayan realizado durante la primera ejecución que genera las dependencias.) He aquí un ejemplo de un Makefile básica que crea un archivo de un archivo stl scad del mismo nombre..:

  1. explicit wildcard expansion suppresses errors when no files are found

include $(wildcard *.deps)

%.stl: %.scad

       openscad -m make -o $@ -d $@.deps $<

Cuando hacer my_example.stl se ejecuta por primera vez, que no encuentra archivos deps, sólo dependerá de my_example.scad;. Desde my_example.stl todavía no está preajustado, se creará incondicionalmente. Si OpenSCAD encuentra los archivos que faltan, los usara para construir la figura, y se mostrará una lista de todos los archivos que se utilizan en my_example.stl.deps. Al hacer que my_example.stl se llame posteriormente, su obnjetivo será encontrar e incluir my_example.stl.deps y comprobar si alguno de los archivos que aparecen allí, incluyendo my_example.scad, cambiado desde my_example.stl se construyó sobre la base de sus marcas de tiempo. Sólo si ese es el caso, se va a construir my_example.stl nuevo. Blancos automáticos: En la construcción de los archivos STL similares desde un único archivo de scad, también hay una manera de automatizarlos:

  1. match "module foobar() { // `make` me"

TARGETS=$(shell sed '/^module [a-z0-9_-]*().*make..\?me.*$$/!d;s/module //;s/().*/.stl/' base.scad)

all: ${TARGETS}

  1. auto-generated .scad files with .deps make make re-build always. keeping the
  2. scad files solves this problem. (explanations are welcome.)

.SECONDARY: $(shell echo "${TARGETS}" | sed 's/\.stl/.scad/g')

  1. explicit wildcard expansion suppresses errors when no files are found

include $(wildcard *.deps)

%.scad:

       echo -n 'use <base.scad>\n$*();' > $@

%.stl: %.scad

       openscad -m make -o $@ -d $@.deps $<

Todos los objetos que se suponen van a ser exportados automáticamente tiene que ser definidos en base.scad en un módulo propio con su futuro nombre de archivo (sin la extensión ". Stl"), y que un comentario como "/ / me hacen" en la línea de la definición del módulo. Los "Targets =" de línea recogen estas fuera del archivo de la base y crean los nombres de archivo. Estos se construirán cuando hacen todo (o hacen, para abreviar) es llamado. Como la convención del último ejemplo es la creación de los archivos. Stl de. Archivos Comisión Científica del mismo nombre base, para cada uno de estos archivos, un archivo. Scad tiene que ser generado. Esto se hace en el ".% SCAD:" párrafo; my_example.scad será un archivo OpenSCAD muy simple: use <base.scad> my_example();

La linea". SECOND" está ahí para evitar que make lo elimine el archivo. Archivos SCAD. Si lo elimina, no sería capaz de determinar automáticamente qué archivos no necesitan reconstruir nada más.