Skip to main content

Fallos en Deviantshare

Resulta que ultimamente (¿ayer?) el blog estuvo redirigiendo a deviantshare.com por problemas con el "gadget", resulta que parece que la página ya no existe, de ahí todo el lío.

Y eso es todo, perdón por las molestias.

Introducción a Structure Synth ( y II )

Bien, seguimos con Structure Synth...

Definición de nuevas reglas

Recordemos que la unidad básica de los scripts de Structure Synth son las reglas (y las reglas más básicas las primitivas), así que existe la posibilidad de definir nuestras propias reglas, esto se hace sencillamente haciendo:

=============================================================================== rule { componentes de la regla } ===============================================================================

Es decir, para hacer una figura similar a una casa (hay que echarle algo de imaginación),se podria hacer =============================================================================== Box { x 0.5 ry 45 s 0.75 } Box =============================================================================== [http://3.bp.blogspot.com/_26RJWnubh-w/TEla_vG4BII/AAAAAAAAANY/X6rXs2IPiqs/ s320/casa.png]

Si se utilizase esta forma varias veces, se podria definir una regla que la construyese directamente:

=============================================================================== rule casa{     Box     { x 0.5 ry 45 s 0.75 } Box } ===============================================================================

Aleatoriedad

Además, si se define una misma regla varias veces, se escojera una aleatoria entre las definidas, por ejemplo, si definimos

=============================================================================== rule micaja{     { color blue } Box }

rule micaja {     { color red } Box }

===============================================================================

Cada vez que llamemos a micaja, obtendremos una caja de color azul o rojo, escogida al azar, por ejemplo:

=============================================================================== 10 * { x 1 } 10 * { y 1 } micaja =============================================================================== [http://2.bp.blogspot.com/_26RJWnubh-w/TEldkHqcKeI/AAAAAAAAANc/g7tRFYygQE4/ s320/tabla.png]

Se puede cambiar la probabilidad de que salga una regla cualquiera simplemente haciendo

=============================================================================== rule weigth { componentes de la regla } ===============================================================================

La probabilidad por defecto es 1, si es 2, hay el doble de posibilidades, con 0.5, la mitad...

Recursividad

Por supuesto, una regla puede llamarse a si misma (recursividad), en estos casos hay que tener en cuenta el parámetro maxdepth (set maxdepth ) que especifica la profundidad máxima que puede alcanzar la recursión. La recursividad no requiere ningun truco, simplemente se llama a la propia regla como se llamaría a cualquier otra, por ejemplo, si recordamos el código de la espiral:

=============================================================================== 360 * { ry 1 x 1 s 0.995 } Box ===============================================================================

Este se puede pasar a recursivo simplemente llamando a la figura base ( aquí Box ) y aplicando las transformaciones a la siguiente recursión: =============================================================================== rule espiral{     Box     { ry 1 x 1 s 0.995 } espiral }

espiral  // Hace falta iniciar el proceso

[http://3.bp.blogspot.com/_26RJWnubh-w/TElipiQ7yAI/AAAAAAAAANk/78_OgXyIVtM/ s320/rec_espiral.png] El resultado es bastante similar, con la diferencia de que no se define un límite, sino que este depende de los parámetros.

Transformaciones geométricas: cambios de tamaño "avanzado"

Hasta ahora para cambiar el tamaño del sistema de coordenadas, lo hemos hecho con todas las dimensiones a la vez, es decir, 'X', 'Y' y 'Z' crecían en la misma proporción, con lo que, por ejemplo, un cubo (Box) era siempre un cubo perfecto, pero se puede cambiar el tamaño de las dimensiones de forma independiente, la transformación entonces es esta: s  

Esto puede parecer un lío al principio, es solo cosa de cojerle el truco, por ejemplo, si queremos una caja (Box) con 0.1 de ancho, 1 de alto, y un 1 de lado haríamos:

=============================================================================== { s 0.1 1 1 } Box =============================================================================== [http://4.bp.blogspot.com/_26RJWnubh-w/TElm5_zStNI/AAAAAAAAANo/SzrPnyOmNYY/ s320/flat.png]

O, si queremos uno con 0.1 de ancho, 2 de alto, y un 0.1 de lado

{ s 0.1 2 0.1 } Box

[http://1.bp.blogspot.com/_26RJWnubh-w/TElo5Pbf4VI/AAAAAAAAANs/UTliDVYOy2c/ s320/pole.png]

Estas figuras pueden ser interesantes para simular líneas, que suelen tener problemas al pasarse por Sunflow, por ejemplo, para hacer un toro con ellas: =============================================================================== 180 * { ry 2 x 0.5 hue 2 } 72 * { rx 5 rz 5 y 1 } basefig

rule basefig{     { s 1 0.1 0.1 } box } =============================================================================== [http://4.bp.blogspot.com/_26RJWnubh-w/TEls671vfkI/AAAAAAAAANw/Na-2LgwL3hA/ s320/mytoro.png]

Fractales Como con logo, los fractales no pueden faltar, copio y pego la "introducción":
Un fractal es un objeto semigeométrico cuya estructura básica,
fragmentada o irregular, se repite a diferentes escalas.[1]Una mejor
manera para comprender el comportamiento fractal de nuestro universo
es considerar la siguiente definición: "Patrones que se repiten a
distintas escalas".
A un objeto geométrico fractal se le atribuyen las siguientes
características:[2]
* Es demasiado irregular para ser descrito en términos
geométricos tradicionales.
* Posee detalle a cualquier escala de observación.
* Es autosimilar (exacta, aproximada o estadística).
* Su dimensión_de_Hausdorff-Besicovitch es estrictamente mayor
que su dimensión_topológica.
* Se define mediante un simple algoritmo_recursivo. Dejemos aparte todo lo de "autosimilar", "dimensiones topologicas" y demas... lo mas comprensible es que "se repite a distintas escalas" y "se define mediante un simple algoritmo recursivo", vamos a probar...

Supongamos que queremos hacer un fractal similar a una alfombra_de_Sierpinski, los pasos para hacerlo son:
1. Poner un cuadrado en el centro
2. Repetir el proceso a menor escala en los lados y diagonales del cuadrado

Perfectamente recursivo, ¿verdad?, además no requiere ninguna herramienta que no proporcione Structure Synth y se aplicar sencillamente a 3D:

  1. Poner un cubo en el centro
  2. Repetir el proceso a menor escala en los lados y diagonales del cubo

El código, que nadie se asuste que el tocho es para que se repita en cada lado, es solo copiar-pegar cambiando las distancias en 'X', 'Y' y 'Z' y  el hue es para que la imágen quede más clara, con diferente color para cada nivel de recursi:

=============================================================================== set background white set maxdepth 5  // Profundidad máxima

define space 3   // Espaciado entre figuras

define ratio 0.33  // Ratio de cambio de tamaño

define color_change 50  // Tamaño de los pasos de cambio de color

sierpinski

rule sierpinski{     { hue color_change s ratio x space  } sierpinski     { hue color_change s ratio x -space } sierpinski

{ hue color_change s ratio y space   } sierpinski     { hue color_change s ratio y -space  } sierpinski

{ hue color_change s ratio z space   } sierpinski     { hue color_change s ratio z -space  } sierpinski

{ hue color_change s ratio x space y space                 } sierpinski     { hue color_change s ratio x space y space  z space   } sierpinski     { hue color_change s ratio x space y space  z -space  } sierpinski     { hue color_change s ratio x space y -space                } sierpinski     { hue color_change s ratio x space y -space  z space  } sierpinski     { hue color_change s ratio x space y -space  z -space } sierpinski

{ hue color_change s ratio x -space y space                 } sierpinski     { hue color_change s ratio x -space y space  z space   } sierpinski     { hue color_change s ratio x -space y space  z -space  } sierpinski     { hue color_change s ratio x -space y -space                } sierpinski     { hue color_change s ratio x -space y -space  z space  } sierpinski     { hue color_change s ratio x -space y -space  z -space } sierpinski

{ hue color_change s ratio y space  z space   } sierpinski     { hue color_change s ratio y space  z -space  } sierpinski     { hue color_change s ratio y -space  z space  } sierpinski     { hue color_change s ratio y -space  z -space } sierpinski

{ hue color_change s ratio z space  x space  } sierpinski     { hue color_change s ratio z space  x -space } sierpinski     { hue color_change s ratio z -space x space  } sierpinski     { hue color_change s ratio z -space x -space } sierpinski

box } =============================================================================== [http://2.bp.blogspot.com/_26RJWnubh-w/TEmraFVvPJI/AAAAAAAAAN8/yN9YsJWmwaw/ s320/carpet_3d.png]

Pasando a algo más complicado, un triángulo_de_Sierpinski, extrapolado a 3D (ya_se_mostró_el_código_para_2D), el proceso sería este:
1. Se dibuja un triangulo (la estructura externa)
2. Se repite el proceso a la mitad de escala en la mitad de cada diagonal

Y esto fue lo mejor que conseguí, sobre todo lo que no me gusta son tantos números que no son "redondos" :( ===============================================================================

define thick 0.05

define linecolor red

define basecolor white

set maxdepth 20

triangulo

rule triangulo {

// Diagonales     { color linecolor  x -0.5  y 0.75 z -0.5 rx 181.7 ry 45 rz 45  s 2.1 thick thick } box     { color linecolor  x -0.5  y -0.75 z 0.5 rx 1.7 ry 45 rz 45  s 2.1 thick thick } box     { color linecolor  x -0.5  y -0.5 z -0.75 rx 91.7 ry 45 rz 45  s 2.1 thick thick } box     { color linecolor  x -0.5  y 0.5 z 0.75 rx 271.7 ry 45 rz 45  s 2.1 thick thick } box

// Base     { color basecolor  x -1.025 rx 11  s 0.05 2.6 2.6} box  

// Niveles interiores

{  s 0.5 } triangulo

{ x -0.5  y 0.73 z -0.495 s 0.5 } triangulo     { x -0.5  y -0.73 z 0.495  s 0.5 } triangulo     { x -0.5  y -0.495 z -0.73  s 0.5 } triangulo     { x -0.5  y 0.495 z 0.73 s 0.5 } triangulo

}

[http://2.bp.blogspot.com/_26RJWnubh-w/TEnK1hORVYI/AAAAAAAAAOA/Ul7ZCMUem4A/ s320/sierpinski_triangle.png]

Además, hablando de fractales no pueden faltar los árboles binarios, esta vez representados en 3D (código e imágen de Vishkey), muy logrado el efecto de las "ramas" al dividirse: =============================================================================== set background #0066CC {s 30 0.1 30 y -5 color #330000} box 4 *{x 2} 4 * {z 2} 1 * {rz 90} r1

rule r1 maxdepth 15 {     c1     {s 0.5 0.5 1 x 1.4 y 0.25 rz 30 b 100} r1     {s 0.5 0.5 1 x 1.4 y -0.25 rz -30 b 100} r1     {s 1 0.5 0.5 z -0.25 x 0.98 ry 30 b 100} r1     {s 1 0.5 0.5 z 0.25 x 0.98 ry -30 b 100} r1 }

rule c1 {     {s 1 0.05 0.05 color green} box } =============================================================================== [http://1.bp.blogspot.com/_26RJWnubh-w/TElzSVTnWFI/AAAAAAAAAN4/3re7f4WQ9-Q/ s320/BosqueArbolesBinarios.bmp]

Por último... no es un fractal, pero me gustó el resultado, aunque es uno diferente cada vez que se ejecuta :P =============================================================================== set maxdepth 500

define color_change 0.5

spiral

rule spiral weight 100{     box     { s 0.999 hue color_change ry 0.5 x 1 } spiral }

rule spiral weight 1{     box     { s 0.95 hue color_change rx 180 ry 1 x 1 } spiral     { s 0.99 hue color_change ry 1 x 1 } spiral }

rule spiral weight 0.01{     box     { s 0.99 hue color_change rx 180 ry 1 x 1 } spiral } =============================================================================== [http://2.bp.blogspot.com/_26RJWnubh-w/TElwzfP4MQI/AAAAAAAAAN0/pwfCzRv2qAU/ s320/espirales.png]

Hasta la próxima.

[Referencias] http://www.fractalforums.com/ http://structuresynth.sourceforge.net/ http://structuresynth.sourceforge.net/reference.php http://sunflow.sourceforge.net/ http://www.fractovia.org/art/es/

ROT 13, Brainfuck y Ook! (+traductor)

Hoy presento uno de los desavarios mas preocupantes que he escrito últimamente, unos programas en Brainfuck (muy sencillos, eso sí)... pero empezemos por el principio.

Actualizado: el traductor ahora también soporta interpretes de Ook! que no permitan comentarios.

Brainfuck

Como dice la Wikipedia:

Brainfuck (jodecerebros), es un lenguaje_de_programación_esotérico,  
diseñado por Urban_Müller en 1993, con el objetivo de hacer un  
lenguaje que fuera a la vez muy simple, Turing_completo y que  
requiriese un compilador pequeño. Müller basó Brainfuck en la  
máquina_de_Turing y le sirvió de inspiración el compilador de 1024  
bytes de tamaño del lenguaje FALSE.  
La distribución clásica es la versión 2 escrita por el propio  
Müller, conteniendo un compilador para el ordenador Amiga, un  
intérprete, programas de ejemplo y un documento "readme".

Brainfuck tiene solo 8 instrucciones:
* >   Incrementa el puntero, en C sería p++ 
* <   Decrementa el puntero, en C sería p--
* +Incrementa el byte al que apunta el puntero, en C p++
* - Decrementa el byte al que apunta el puntero, en C p
--
* [Salta hasta el], si el byte apuntado es 0, en C  while (p){
* ] Salta hasta el [, si el byte apuntado es distinto de 0, en C sería el
} del while
* . Muestra por pantalla el valor apuntado, en C putchar(p
);
* , Acepta un valor por STDIN y lo guarda en el byte apuntado, p*=getchar
();

El resto de caracteres se ignora, el Hola mundo, por ejemplo, sería (sacado de Wikipedia):

++++++++++  
[              Bucle para iniciar las memorias (se repite 10 veces)  
 >+++++++>++++++++++>+++++++++++>+++>+<<<<<-  
      70        100       110      30  10  
]  
>++.              imprime 'H'   (72) 1  
>>+.              imprime 'o'  (111) 3  
---.                      'l'  (108) 3  
<---.                     'a'   (97) 2  
>>++.                   espacio (32) 4  
<+.                       'm'  (109) 3  
++++++++.                 'u'  (117) 3  
-------.                  'n'  (110) 3  
<+++.                     'd'  (100) 2  
>+.                       'o'  (111) 3  
>+.                       '!'   (33) 4  
>.                   nuevalínea (10) 5

Ook!

Además, este lenguaje dio lugar a otro, llamado Ook!, un lenguaje "diseñado para orangutanes":

Ook! (con el signo_de_exclamación) es un lenguaje_de_programación  
esotérico Turing_completo. Este lenguaje es una parodia de  
Brainfuck, del que toma su conjunto completo de comandos (ver tabla).  
Deriva su completitud Turing de esta relación.  
Según su diseñador, David_Morgan-Mar, el lenguaje está diseñado  
para orangutanes. Tiene 3 palabras_reservadas (Ook., Ook?, y Ook!);  
que pueden combinarse en ocho maneras diferentes para formar el  
repertorio de instrucciones del lenguaje. Ook! pretende ser fácil de  
aprender para los orangutanes y evitar cualquier mención de la  
palabra «mono». [Wikipedia]

Comparten el set de instrucciones, cambiando solo su nombre, esta es la relación de los comandos Brainfuck - Ook!
* > : Ook. Ook?   Incrementa el puntero, en C sería p++ 
* < : Ook? Ook.   Decrementa el puntero, en C sería p--
* + : Ook. Ook.Incrementa el byte al que apunta el puntero, en C p++
* - : Ook! Ook! Decrementa el byte al que apunta el puntero, en C p
--
* [ : 
Ook! Ook?Salta hasta el], si el byte apuntado es 0, en C  while (p){
* ] : Ook? Ook! Salta hasta el [, si el byte apuntado es distinto de 0, en
C sería el } del while
* . : Ook! Ook. Muestra por pantalla el valor apuntado, en C putchar(p
);
* , : Ook. Ook! Acepta un valor por STDIN y lo guarda en el byte apuntado,
p*=getchar();

ROT 13

Y por último, ROT 13, este no es un lenguaje de programación, solo un sistema clásico de cifrado de tipo césar ("movía" las letras n veces hacia la derecha) con la peculiaridad de que al mover las letras 13 veces, el cifrado y el descifrado se hacían igual.Así de simple, si quieres ver más -> https:// secure.wikimedia.org/wikipedia/es/wiki/ROT13

Al tema...

Bien, el "reto" era escribir un programa en Brainfuck que cifrase con ROT-13 y otro que convirtiese un código en ese lenguaje a Ook!, para empezar, como base y para entender mejor el lenguaje, escribí un programa que guardase lo que el usuario dijera y lo devolviese despues por pantalla.

Este es el código,el caracter para detener la entrada es Enter, más que nada porque es más fácil de utilizar:

Guarda lo que dice el usuario, hasta que pulse enter  
>+[>,----------]  
Vuelve al principio de la cadena  
+++  
[<]>>  
Muestra los caracteres  
[++++++++++.>]  
Salta a una nueva linea  
++++++++++.

Por muy críptico que parezca, en realidad es bastante sencillo si se lee paso a paso:

{Línea 1} Primero se salta a un nuevo puntero ( > ), para dejar este intacto (con valor 0), y que sirva como limitador de la cadena, después se suma 1 al valor apuntado, para poder entrar en el while. Una vez en el while se vuelve a incrementar ( > ) el puntero, esto se hace para conseguir un byte diferente por cada letra que el usuario introduzca, en ese byte se introduce lo que usuario mande ( , ), y a este valor se le resta 10 ( - --------- ) para hacer que si es un salto de línea, que tiene el valor 10, se quede a 0, en el resto de valores se revertirá. y se acabe el bucle, por último se cierra el while ( ] ).

{Línea 2} Se suman 3 al valor apuntado ( +++ ), este byte corresponde al Enter del usuario, se podría pensar que hay que dejarlo a 0, para que luego al sumar 10 a todo para recuperar los valores originales se muestre el enter, el problema es que no debe estar a 0, ya que sino no podremos "entrar" en el siguiente while, así que añadiendo 3, más los 10 posteriores se convierte en un retorno de carro, y no molesta por el medio.

{Línea 3} Se vuelve al principio, haciendo while ( [ ) y retrocediendo el puntero ( < ) , hasta que finalmente se encuentre con el valor 0 que dejamos al principio, y que hará que el programa salga del bucle ( ] ), una vez ahí avanzamos 2 veces el puntero ( > ) y ( > ), uno por el valor nulo y otro por el 1 que dejamos para poder entrar en el bucle del principio.

{Línea 4} Solo queda ir leyendo carácter a carácter con un bucle ( [ ), sumando 10 para recuperar los valores originales ( ++++++++++ ) , mostrarlos por pantalla ( . ) y saltar al siguiente carácter ( > ), el bucle acabará ( ] ) con el último carácter, que será un 0

{Línea 5} Solo queda hacer el salto de línea que cambiamos por un retorno de carro, simplemente añadiendo 10 al valor nulo actual (++++++++++ )  y mostrandolo por pantalla ( . ) .

Si te parece extraño (que lo es, para que nos vamos a engañar), piensa que pinta tendría el código solo:

+[>,----------]+++[<]>>[++++++++++.>]++++++++++.

Aunque también se podría hacer por la vía fácil:
+[,.----------] ¿Pero que gracia tendría así?

"Cifrando" y "descifrando" (con ROT 13)

Por cosas de la vida, no se pueden aprovechar las facilidades del ROT 13, ya que la aritmética es nula, así que habrá que conformarse con hacer un par de programas, uno que añada 13 y otro que los reste, esto se puede hacer sencillamente aprovechando el programa que repite lo que dice el usuario, solo hay que añadir una parte que añada 13 antes de mostrar el valor "cifrado" y que los reste antes del "descifrado",  el añadido es obvio, lo único que merece la pena comentar es que el movimiento adicional de punteros es para evitar que queden caracteres feos por el medio con las rotariones (el 13 es invisible, pero el 26, 13+13, no siempre ) :

Cifrar:

+[>,----------] Vuelve al principio de la cadena +++ [<]>>> Imprime la info [<++++++++++ +++++++++++++.>>] Imprime un espacio ++++++++++.

Descifrar:

+[>,----------] Vuelve al principio de la cadena +++ [<]>>> Imprime la info [<++++++++++ -------------.>>] Imprime un espacio ++++++++++.

Traduciendo a Ook!

Y Ook! ... tenía escrito un traductor de Brainfuck a Ook!, pero me lo cargué :(, a ver si lo reescribo, sinó habra que conformarse con este script en python. EDIT (00:15): al final si que hay traductor, lo conseguí reescribir de 0, y la verdad... quedé contento con el resultado, está coloreado despues de las referencias o [aquí], como detalle comentar que los datos acaban con un "\0" , así que quiza sea mejor usarlo así:

=============================================================================== (cat loquesea.b ;echo -e "\0")|./bf2ook > loquesea.ook ===============================================================================

ps: Pygments es sorprendente, hasta colorea esto :P

Hasta otra, si es que queda alguien cuerdo por ahí... :)

[Referencias] http://codegolf.com/brainfuck https://secure.wikimedia.org/wikipedia/es/wiki/Brainfuck https://secure.wikimedia.org/wikipedia/es/wiki/Ook!

===============================================================================
(Primero se preparan las letras)
>           (Para uso posterior) (L 1)
>>> (Esta memoria me la reservo) (L 3)
O = 79
o = 111
k = 107
! = 33
? = 63
(punto) = 46
(espacio) = 32
++++++++++ (L 4)
[
      >++++++++ ( 8 )   (L  5)
      >+++++++++++ (11) (L  6)
      >+++++++++++ (11) (L  7)
      >+++ (3)          (L  8)
      >++++++ (6)       (L  9)
      >+++++ (5)        (L 10)
      >+++ (3)          (L 11)
      <<<<<<<-          (L  4)
]
>-     (L  5)
>+     (L  6)
>---   (L  7)
>+++   (L  8)
>+++   (L  9)
>----  (L 10)
>++    (L 11)
<<<<<<< (L 4)
<<< (Se vuelve al principio) (L 1)
,   (Se lee lo que el usuario dice)  (L 1)
[
    (Se copia por si no es codigo )
    (en el nivel 2 L = 2)
    [>+>+<<-]
    >>        (L 3)
    [-<<+>>]
    <<        (L 1)

    (Por defecto NO es codigo)
    >>>+ (L 4)
    <<<  (L 1)
    (El L = 3 se usa para buscar los valores)
    >>++++ (L 3)
    [<<---------- (L 1) >> -] (L 3)
    <<--- (L 1)
    [   (Si no es un mas)
        - (L 1)
        [   (Si no es una coma)
            -    (L 1)
            [   (Si no es un menos)
                -  (L 1)
                [   (Si no es un punto)
                    -------------- (Menos 14) (L 1)
                    [   (Si no es un menor que)
                        -- (L 1)
                        [   ( Si no es un mayor que )
                            <++++ (L 0)
                            [->-------<] (Se resta 28)
                            >     (L 1)
                            -     (L 1)
                            [   ( Si no abre corchetes )
                                -- (L 1)
                                [   ( Si no cierra corchetes )
                                    > (Anhade un punto si permite
comentarios) (L 2) (No es codigo dice el caracter a secas)
                                    >> - (L 4) ( Parece que no pero
es dificil no meter )
                                    <<< (L 1)  ( codigo sin querer en
los comentarios )
                                    [-] (Pone el caracter actual a 0)
                                ]
                                >>> (L 4)
                                [   ( Si cierra corchetes )
                                    >.   (L  5)
                                    >.   (L  6)
                                    >.   (L  7)
                                    >>.   (L  9)
                                    >>.   (L 11)
                                    <<<<<<< (L 4)
                                    >.   (L  5)
                                    >.   (L  6)
                                    >.   (L  7)
                                    >.   (L  8)
                                    >>>.   (L 11)
                                    <<<<<<< (L 4)
                                    - (L 4)
                                ]
                                <<< (L 1)
                            ]
                            >>> (L 4)
                            [   ( Si abre corchetes
                                >.   (L  5)
                                >.   (L  6)
                                >.   (L  7)
                                >.   (L  8)
                                >>>.   (L 11)
                                <<<<<<< (L 4)
                                >.   (L  5)
                                >.   (L  6)
                                >.   (L  7)
                                >>.   (L 9)
                                >>.   (L 11)
                                <<<<<<< (L 4)
                                - (L 4)
                            ]
                            <<< (L 1)
                        ]
                        >>> (L 4)
                        [   ( Si es un mayor que )
                            >.   (L  5)
                            >.   (L  6)
                            >.   (L  7)
                            >>>. (L 10)
                            >.   (L 11)
                            <<<<<<< (L 4)
                            >.   (L  5)
                            >.   (L  6)
                            >.   (L  7)
                           >>.   (L 9)
                           >>.   (L 11)
                           <<<<<<< (L 4)
                           - (L 4)
                        ]
                        <<< (L 1)
                    ]
                    >>> (L 4)
                    [   (Si es un menor que)
                        >.   (L  5)
                        >.   (L  6)
                        >.   (L  7)
                        >>.   (L 9)
                        >>.   (L 11)
                        <<<<<<< (L 4)
                        >.   (L  5)
                        >.   (L  6)
                        >.   (L  7)
                        >>>. (L 10)
                        >.   (L 11)
                        <<<<<<< (L 4)
                        - (L 4)
                    ]
                    <<< (L 1)
                ]
                >>> (L 4)
                [   ( Si es un punto)
                    >.   (L  5)
                    >.   (L  6)
                    >.   (L  7)
                    >.   (L  8)
                    >>>.   (L 11)
                    <<<<<<< (L 4)
                    >.   (L  5)
                    >.   (L  6)
                    >.   (L  7)
                    >>>. (L 10)
                    >.   (L 11)
                    <<<<<<< (L 4)
                    - (L 4)
                ]
                <<< (L 1)
            ]
            >>> (L 4)
            [   ( Si es un menos)
                >.   (L  5)
                >.   (L  6)
                >.   (L  7)
                >.   (L  8)
                >>>.   (L 11)
                <<<<<<< (L 4)

                >.   (L  5)
                >.   (L  6)
                >.   (L  7)
                >.   (L  8)
                >>>.   (L 11)
                <<<<<<< (L 4)
                - (L 4)
            ]
            <<< (L 1)
        ]
        >>> (L 4)
        [   ( Si es una coma)
            >.   (L  5)
            >.   (L  6)
            >.   (L  7)
            >>>. (L 10)
            >.   (L 11)
            <<<<<<< (L 4)

            >.   (L  5)
            >.   (L  6)
            >.   (L  7)
            >.   (L  8)
            >>>.   (L 11)
            <<<<<<< (L 4)
            - (L 4)
        ]
        <<< (L 1)
    ]
    >>> (L 4)
    [   (Si es un mas)
        >.   (L  5)
        >.   (L  6)
        >.   (L  7)
        >>>. (L 10)
        >.   (L 11)
        <<<<<<< (L 4)
        >.   (L  5)
        >.   (L  6)
        >.   (L  7)
        >>>. (L 10)
        >.   (L 11)
        <<<<<<< (L 4)
        - (L 4)
    ]
    <<< (L 1)
    >[-] (Limpiando)  (L 2)
    >[-] (Limpiando)  (L 3)
    << (L 1)
    , (Se lee lo que el usuario dice)  (L 1)
] ===============================================================================

Introducción a Structure Synth ( I )

Nada, ya está la primera parte de esta introducción a Structure_Synth, sin mas dilación...

Todos lo que se puede hacer en Structure Synth se basa en unos elementos básicos llamados reglas, las reglas básicas (llamadas primitivas) son:

  • Sphere (esfera) [http://3.bp.blogspot.com/_26RJWnubh-w/TESbLnXFlrI/AAAAAAAAAMU/WkZo-TcXQWA/ s320/sphere.png]

  • Box (caja) [http://1.bp.blogspot.com/_26RJWnubh-w/TESbMjbb_vI/AAAAAAAAAMY/dYJLkeWHL3o/ s320/box.png]

  • Grid (Rejilla) [http://3.bp.blogspot.com/_26RJWnubh-w/TESbOPkyi8I/AAAAAAAAAMg/zxdi_EYpfcM/ s320/grid.png]

  • Line (Línea) [http://4.bp.blogspot.com/_26RJWnubh-w/TESbNI8TUfI/AAAAAAAAAMc/A-M_soM3WpA/ s320/line.png]

Lo único necesario para que se muestre una regla es poner su nombre en el archivo que se va a "leer", por ejemplo

=============================================================================== Sphere =============================================================================== Mostraría una esfera.

Como no, este lenguaje permite comentarios multilínea, desde  /   hasta / y comentarios de una sola línea, poniendo // al principio del comentario, como cualquier comentario en C.

Por cierto, si estas viendo que las imágenes tienen el fondo en blanco, pero si lo haces tu no, es por que hay que añadir

=============================================================================== set background white =============================================================================== Ya explicaré más tarde para que sirve, pero no afecta a la programación en si.

Transformaciones geométricas: Movimiento, Traslaciones

En este lenguaje siempre se parte del sistema de coordenadas, para mover una regla lo que hay que hacer es mover sus coordenadas a través de lo que se llaman transformaciones, estas se especifican entre '{'  '}' antes de una regla, para mover el sistema de coordenadas del eje X en 2 unidades haremos { x 2 } regla

Lo mismo para cualquier otro eje ('Y' o 'Z'). Así si queremos poner dos cajas separadas, haremos

=============================================================================== Box { x 2 } Box =============================================================================== El resultado es este: [http://1.bp.blogspot.com/_26RJWnubh-w/TESfluHPlUI/AAAAAAAAAMo/7p6049Gm7rs/ s320/box2.png]

Hay que recordar que las transformaciones solo se aplican para esa regla en concreto, las nuevas reglas seguirán partiendo del sistema de coodenadas original.

=============================================================================== Box { x 2 } Box { x 4 } Box =============================================================================== [http://1.bp.blogspot.com/_26RJWnubh-w/TESgH44zjDI/AAAAAAAAAMs/ueK2lZ6uuUk/ s320/box3.png]

Esto se puede hacer pesado si se tiene que repetir muchas veces, así que se puede utilizar un bucle que lo haga, la sintaxis para hacerlo es: * { }

Por ejemplo, si queremos que se repita lo que hemos estado haciendo (poner cajas separadas), digamos... 10 veces, haremos:

=============================================================================== 10 * { x 2 } Box ===============================================================================

Importante: Cada iteración del bucle parte del sistema de coordenadas de la anterior (la primera parte del original)

[http://3.bp.blogspot.com/_26RJWnubh-w/TESh9jU1CFI/AAAAAAAAAMw/VxQHJSEFRxQ/ s320/box4.png]

Por supuesto, también se pueden anidar para hacer cosas más complejas, por ejemplo:

=============================================================================== 10 * { x 2 } 10 * { y 2 } Box ===============================================================================

[http://3.bp.blogspot.com/_26RJWnubh-w/TESj_cEjewI/AAAAAAAAAM0/O3kOrFs5LGo/ s320/box5.png]

Transformaciones geométricas: Rotaciones

Otro tipo de movimiento que se realiza a través de las transformaciones es el de rotación, pero como la posición inicial depende del sistema de coordenadas, lo que se hace es rotar este sistema, por ejemplo, para rotarlo sobre el eje Y ( se "moverán" los ejes 'X' y 'Z' ), especificaremos una transformación ry (rx o rz para los ejes 'X' y 'Z' respectivamente )

Entonces, para dibujar un circulo solo hay que poner una caja, girar el eje 'X' (rotando sobre uno de los otros dos), y avanzar sobre este eje, repitiendo esto hasta que se hayan completado los 360 grados, por ejemplo:

=============================================================================== 360 * { ry 1 x 1 } Box =============================================================================== [http://1.bp.blogspot.com/_26RJWnubh-w/TESmanGWP3I/AAAAAAAAAM4/1s4sOuZ0y_4/ s320/box6.png]

Transformaciones geométricas: Cambios de tamaño

Además se puede cambiar el tamaño del sistema de coordenadas, hacerlo implica cambiar el tamaño de las figuras y la distancia que se recorrerá con los mismos valores, la transformacion es: s  

La proporcion original es 1, 2 el doble, 0.5 la mitad... Si al ejemplo anterior se le añade esta transformación...

=============================================================================== 360 * { ry 1 x 1 s 0.995 } Box =============================================================================== [http://3.bp.blogspot.com/_26RJWnubh-w/TESpZmdusxI/AAAAAAAAAM8/hOBAi0BlHww/ s320/spiral.png]

Si se añaden más iteraciones la espiral continúa...

=============================================================================== 1080 * { ry 1 x 1 s 0.995 } Box =============================================================================== [http://2.bp.blogspot.com/_26RJWnubh-w/TESpeZUvU2I/AAAAAAAAANA/4zYBbUU_hYk/ s320/spiral2.png]

Transformaciones de color: Tono, saturación y brillo

Structure Synth usa un tipo de color llamado HSV_(Tono,_saturación_y_valor), en vez del RGB, esto divide los colores en 3 valores, tono, la saturación y el valor (o brillo). Tono es el "color" que tiene: rojo, verde, azul... La saturación, que indica la cantidad de color (va de blanco a todo color). Y el valor (o el brillo), que indica la cantidad de luz (de blanco a negro).

El tono va de 0 a  360 y vuelta a empezar (361 es igual a 1), su transformación es hue  

Para ver como funciona de una forma más grafica, volveré al ejemplo del circulo (por problemas con Structure Synth esta pasado por Sunflow) ...

=============================================================================== 360 * { ry 1 x 1 hue 1 } Box =============================================================================== [http://2.bp.blogspot.com/_26RJWnubh-w/TESwC92AldI/AAAAAAAAANE/DjRhanD6C_g/ s320/circle_hue.png]

La saturación es una proporción (como el cambio de tamaño), la transformación es  sat  

Volviendo al caso de las cajas contiguas:

=============================================================================== 10 * { x 1 sat 0.8 } Box =============================================================================== [http://1.bp.blogspot.com/_26RJWnubh-w/TESx4bzDMCI/AAAAAAAAANI/p3Fso7Mw7_0/ s320/line_sat.png]

El valor (o brillo) es también una proporción, de 1 (claro) a 0 (negro), la transformación es b

Siguiendo con el ejemplo de las cajas contiguas

=============================================================================== 10 * { x 1 b 0.8 } Box =============================================================================== [http://4.bp.blogspot.com/_26RJWnubh-w/TESzEuKMy9I/AAAAAAAAANM/JDlgwcwWjEs/ s320/line_sat.png]  Transformaciones de color: Alfa y colores absolutos

El alfa (o alpha) es el grado de transparencia que tiene un objeto, es una proporción, de opaco a totalmente transparente, la transformación es  a

Si seguimos con las cajas...

=============================================================================== 10 * { x 1 a 0.8 } Box =============================================================================== [http://1.bp.blogspot.com/_26RJWnubh-w/TES0UhmjoeI/AAAAAAAAANQ/KYbcmbe5BCs/ s320/line_a.png]

Por último decir que Structure Synth permite usar colores absolutos con la transformación  color

Los colores pueden ser RGB (rojo: #FF0000, verde: #0000FF ...) y los colores predefinidos de SVG (red, lightred, blue, gray ...)

Parámetros y preprocesador

Structure Synth se basa en unos parámetros para definir el "límite" de lo que se renderizará (ahora puede que no parezca muy lógico, pero con recursividad lo será), estos parámetros se especifican con:

set maxdepth       // Número máximo de generaciónes (iteraciónes o recursividad) antes de acabar set maxobjects      // Número máximo de objetos antes de acabar set minsize      // Tamaño mínimo de los objetos que se mostrarán antes de acabar set maxsize      // Tamaño máximo de los objetos que se mostrarán antes de acabar set background       // Color de fondo (en RGB o con las palabras clave de SVG)

El preprocesador sirve para definir constantes de la misma forma que se hace en C, no tiene ninguna dificultad...

define nombre_de_la_constante constante

Mezclando un poco de todo...

=============================================================================== 1080 * { ry 1 x 1 hue 1 s 0.997 } Box ===============================================================================

[http://3.bp.blogspot.com/_26RJWnubh-w/TETIEy2b9eI/AAAAAAAAANU/r9rWXubLDtA/ s320/spiral_color.png]

Eso es todo por ahora, con el próximo más y mejor: definir nuevas reglas, recursividad, fractales, aleatoriedad...

Hasta entonces

Structure Synth y Sunflow, diseño en 3D

Hoy traigo un par de herramientas, de las que supe por un mail, son Structure Synth y Sunflow.

Structure Synth se encarga de la parte del diseño, con una peculiaridad, en vez de hacer las figuras a mano, se las "describe" a través de una gramatica... para entendernos, se programan, pero a diferencia de la mayoria de los lenguajes, no hay variables (hay parámetros, pero solo unos predefinidos) ni condiciones, todo está definido como un conjunto de figuras ("rules", reglas), que son algunas figuras básicas (cubos, esferas, lineas...). El truco suele estar en usar la recursividad de las reglas (que una misma regla se llame a si misma, lo que lo hace ideal para generar fractales) y , aunque menos, las repeticiones, como repetir muchos cubos para hacer una especie de aro.

Solo un comentario, si usas GNU/Linux, probablemente el paquete del repositorio falle, así como la compilación desde el código, a falta de otra solución mejor, se puede usar Wine con el paquete de Windows, que sorprendentemete va muy bien es usable aún emulado, supongo que porque no usa ninguna librería única de Windows (¿?) Página web: http://structuresynth.sourceforge.net/ Descarga: http://structuresynth.sourceforge.net/download.php

Sunflow se encarga de la parte del renderizado, si exportamos las imágenes de Structure Synth, (F6) y se las pasamos a Sunflow, el resultado será mucho mejor que el propio de Structure Synth.

Este funciona perfectamente con GNU/Linux (está en java). Página web: http://sunflow.sourceforge.net/ Descarga: http://sunflow.sourceforge.net/index.php?pg=down (o el sistema de paquetes de tu SO)

En los próximos post intentaré hacer un tutorial sobre Structure Synth (el uso básico de Sunflow, a partir de archivos ya generados, es fácil), ya que no hay ninguno por la red.

Sin más dilación algunas muestras de lo que se puede hacer con estos dos programas:

La primera es obra de Vishkey, responsable de que haya encontrado estos programas, es un triángulo_fractal:

[http://2.bp.blogspot.com/_26RJWnubh-w/TD41Jvc5L4I/AAAAAAAAAL0/W0K-B7ml2UA/ s320/sierpinski_2d.png] =============================================================================== set maxobjects 1000000

R1

rule r1 maxdepth 5 > c2 { //El 5 hace referencia a la profundidad del fractal    {s 0.5 hue 5}  R1    {s 0.5 x 1 hue 5} R1    {s 0.5 y 0.865  x 0.5 hue 5} R1 }

rule c2 {   linea   {rz 60 x 0.25 y 0.433} linea   {rz -60 x -0.25 y 0.433} linea }

rule linea {  {s 1 0.1 0.1} box }

===============================================================================

Otro código del mismo autor (con este me tome la libertad de bajar el maxdepth a 50 porque sino, con Wine, el renderizado no era posible):

[http://1.bp.blogspot.com/_26RJWnubh-w/TD5BVCvnFaI/AAAAAAAAAL4/LrkYoI3pjpU/ s320/estrella.png] =============================================================================== r2

rule r2 maxdepth 100 {   4 * {rz 90 hue 4} r1   { s 0.75 z 1 rz 30 a 39} r2 }

rule r1 maxdepth 100{   box   {s 0.9 y 0.3 rz 5} r1 } ===============================================================================

Un ejemplo de la web, que también tiene su interes:

[http://1.bp.blogspot.com/_26RJWnubh-w/TD5HMbWqShI/AAAAAAAAAMA/kd_cNe8UdGI/ s320/toro_example.png] =============================================================================== / Sample Torus. /

set maxdepth 100 r1

36 * { x -2 ry 10   } r1

rule r1 maxdepth 10 {    2 * { y -1 } 3 * { rz 15 x 1 b 0.9 h -20 } r2    { y 1 h 12 a 0.9 rx 36 } r1 }

rule r2 {    { s 0.9 0.1 1.1 hue 10 } box // a comment }

rule r2 w 2 {    { hue 113 sat 19 a 23 s 0.1 0.9 1.1 } box } ===============================================================================

Y por último, un aporte propio:

[http://2.bp.blogspot.com/_26RJWnubh-w/TD5Guu5Ud1I/AAAAAAAAAL8/b6I5-JhBxDs/ s320/trisquel_3d_light.png] =============================================================================== /*

Trisquel Structure Synth figure. */

set maxdepth 75

{ color #195EB9 } base

rule spiral_base {   { x 1 rz 6 ry 6 s 0.975 } spiral_base   { s 1 } box }

rule arm1 {   { rx 140 } spiral_base }

rule arm2 {   { rx 60 ry 36 rz 120 } spiral_base }

rule arm3 {   { ry -60 rz 180 }  spiral_base }

rule base {     arm1     arm2     arm3     { s 2} sphere } ===============================================================================

Hasta la próxima.

jGuess: Reconociendo tipos de archivos por los números mágicos

Actualización: Arreglado el problema del "ejecutable"... lo que tiene  no comprobar las cosas

Hoy traigo un pequeño experimento en Java, una especie de file con GUI

Si alguna vez habéis intentado ver (por ejemplo) lo que hay en la carpeta de caché de Firefox, todos los archivos están sin extensión, en estos casos se puede utilizar simplemenente el comando file, pero para quien no tenga una máquina *nix, o no quiera andar con el terminal, quizá quiera probar esto, no es ni de lejos tan potente como file, pero puede servir, además puede añadir las extensiones automáticamente.

[http://3.bp.blogspot.com/_26RJWnubh-w/TDw63PKlOXI/AAAAAAAAALw/lSQzqK9OrlU/ s320/Pantallazo-8.png]

O con archivos normales: [http://4.bp.blogspot.com/_26RJWnubh-w/TDw3b5aJvsI/AAAAAAAAALs/g82dEi049QU/ s320/Pantallazo-6.png]

Para descargar: [jguess.zip] ( descomprimir y ejecutar el .JAR ) El código fuente: [jguess_src.zip]

Tiene algunas carencias (no soporta los que tienen números variables, como avi), pero para algo rápido sirve. El que esté en inglés es por que gran parte del código de los números mágicos ya lo tenía escrito, en inglés, y por no cambiar todo... xD

ps: a ver si luego subo algo de un programa de arte en 3D que está simplemente genial, Stay tuned

[Referencias] http://www.garykessler.net/library/file_sigs.html (algunas) https://secure.wikimedia.org/wikipedia/en/wiki/Magic_number_%28programming%29 http://www.digitalpreservation.gov/formats/ (algunas)

Script para comprobar una lista de proxies SOCKS4

Traigo un script que filtra una lista de proxies con el formato de host:puerto y devuelve una lista de los que funcionan, ordenados de mayor a menor velocidad.

El código se basa uno_anterior, y se puede encontrar aquí [ http:// pastebin.com/AF1RmgJj ]

Todos los parámetros se consideran archivos de proxies, además el texto que se envía en las pruebas (proxy que se está probando y tiempos) se pasan por stderr, mientras que la lista final por stdout, así que se pueden redireccionar fácilmente.

Ah, sí, los dos números que muestra al probar los proxy son, primero tiempo que tarda en conectarse al proxy y segundo, tiempo que tarda el proxy en conectarse a otro host (hay una variable por ahi para definir cual es, por defecto se conecta a la IP de google en el puerto 80 )

Y por último una lista ya filtrada

===============================================================================

213.192.3.66:1080 195.117.61.210:1080 195.205.171.48:1080 207.102.11.254:1080 222.168.18.227:1080 218.241.238.141:1080 121.8.124.42:1080 222.188.10.1:1080 219.150.227.111:1080 218.1.118.122:1080 219.139.35.67:1080 218.56.21.226:1080 123.13.206.59:1080 221.2.144.135:1080 219.157.200.19:1080 119.115.136.150:1080 218.31.134.111:1080 112.64.180.114:1080 190.3.82.132:1080 80.167.238.78:1080 187.4.205.153:1080

===============================================================================

Salu0b10

Script para hacer animaciones con CFDG

Hoy traigo un script que genera automaticamente un conjunto de imágenes con CFDG [cfanim.pl]. Lo que hace es partir de un archivo de este programa, partiendo de un nivel de recursividad pequeño y avanzando, por ejemplo, partiendo del archivo:

===============================================================================

startshape init

rule init{ spiral{sat 1 b 0.8} }

rule spiral{ SQUARE{} spiral{x 1 r 1 hue 1 s 0.999} }

===============================================================================

Se pueden obtener las imágenes desde el primer nivel de recursividad, hasta, digamos... el 300

===============================================================================

./cfanim.pl base.cfdg -i 1 -f 300

===============================================================================

Nota: Es importante no partir del 0, porque se utilizaría en esa imágen el nivel de recursividad normal, no el especificado.

Con ese comando obtendríamos 300 imágenes individiales, pero si además queremos juntarlas para convertirlas en un .gif, se haría:

===============================================================================

./cfanim.pl base.cfdg -i 1 -f 300 -m animacion.gif

===============================================================================

La sintaxis del script es:

===============================================================================

./cfanim.pl -i  -f  [-s ] [-m  [-d ]]

===============================================================================

Por ejemplo, en el ejemplo anterior haciendo un gif de los 1000 primeros frames con 1 centésima de segundo entre cada una se haría:

===============================================================================

./cfanim.pl base.cfdg -i 1 -f 1000 -m animacion.gif -d 1

===============================================================================

Y eso es todo, hasta otra.

Introducción a Structure Synth (y III), el regreso

Gracias a Vishkey, descubrí hace un tiempo que las posibilidades que brinda Structure Synth van más allá de lo mencionado_anteriormente, pues resulta que también soporta texturas más complejas, siempre partiendo de las mismas figuras básicas, cuales son dependen de la plantilla usada para exportar, como la plantilla "Sunflow-Ultimate-Groovelock", que como se encuentra entre las que están por defecto, servirá de ejemplo.

La sintaxis es la siguiente:

===============================================================================

::

===============================================================================

Así, si queremos hacer una esfera con una textura de cristal ("glass"), haremos

===============================================================================

sphere::glass

===============================================================================

Este ejemplo muestra brevemente como se ven las texturas

===============================================================================

set background black {color white x -0.50005 s 0.001 1000 1000}box::ao // Base

{color white }sphere::glass

{color white x 10 s 0.5 1000 1000}box::shiny // Luz/techo

{ color blue y -2 }sphere::diffuse

{ color white y -4 } sphere::mirror

{color red y -6 } sphere::ao

{color black y -8 }sphere::constant

{color white y -10} sphere::phong

{color white y -12} sphere::ward

===============================================================================

De izquierda a derecha, las texturas "glass" en blanco, "diffuse" en azul,"mirror" en blanco,"ao" en rojo,"constant" en negro,"phong" y "ward" en blanco. Además hay una caja que sirve de suelo (con una textura "ao" en blanco) y otra que ilumina la escena (con una textura "shiny" también en blanco).

Este otro ejemplo, (escrito por Vishkey) muestra más claramente las posibilidades que hay

===============================================================================

//Autor: Vishkey

{s 2} room

esferas

rule room { {color brown}pared {z 20} paredLuminosa {rx 90 z 10 y 10 color green} pared {rx 90 z -10 y 10 color blue} pared {ry 90 z 10 x -10 color yellow} paredEspejo {ry 90 z -10 x -10 color white} paredEspejo }

rule esferas { {s 2 z 1 x 2 color white} sphere::glass {s 2 z 1 x 1 y 1 color white} sphere::mirror {s 2 z 1 x 1 y -1 color blue} sphere::phong {s 2 z 1 x 2 y 2 color green} sphere::ao {s 2 z 1 x 2 y -2 color yellow} sphere::constant {s 2 z 1 x 1 y -3} sphere::diffuse {s 2 z 1 x 2 y -4} sphere::shiny {s 2 z 1 x -2 y -3 color white} box::ward {s 2 z 1 x -3 y -2 color white} box::ao {s 2 z 1 x -2 y -1 color white} box::phong {s 2 z 1 x -3 color white} box::glass }

rule pared { {s 20 20 1} box }

rule paredLuminosa { {s 20 20 1} box::shiny }

rule paredEspejo { {s 20 20 1} box::mirror }

===============================================================================

Como se puede ver, el resultado es una delicia para los ojos aun con pocos elementos... aunque quizá demasiado perfecto =). Por último añadir que la plantilla usada "Ultimate-Groovelock" añade algunas luces por su cuenta (se aprecia en algunos reflejos), en caso de querer tener un control total de la imágen estas se podrían eliminar buscando las secciones light adecuadas de la plantilla y eliminándolas o cerrando la escena con cajas... es elección de cada uno.

Hasta otra.

SSH: Conexiones seguras para tod@s ( II ) SSHFS

Siguiendo con la segunda parte de SSH:_Conexiones_seguras_para_tod@s, ahora SSHFS... la idea era mostrar tambien las VPN's, pero ahora mismo no es posible  :(, prometo que pronto saldran ;)

SSHFS

¿ Que es SSHFS ? Es un cliente que permite montar un sistema de archivos remoto en una carpeta local ("bajo la superficie", el cliente funciona con SFTP, con lo que las comunicaciones van cifradas adecuadamente)

Instalandolo La instalacion es la tipica, no me voy a liar con esto, lo unico decir que usa FUSE, si no viene instalado por defecto (que me extraña), cualquier gestor de paquetes decente deberia instalarlo con sshfs, el resto es el clasico sudo apt-get install sshfs

(para basados en debian, por ejemplo)

Montando una carpeta El comando para montar una carpeta es sshfs [@]:[] [-p ]

Los paráetros son:

* Usuario: si el usuario es distinto en el host que el que se esta
utilizando actualmente

* Host: direccion a la que se conecta

* Directorio: raiz de sistema de archivos (si es distinta al directorio
HOME del usuario)

* Puerto: si se usa un puerto SSH no estandar (distinto del 22)
*
* Punto de montaje: carpeta local a traves de donde se accede al SSHFS
*

Como se puede ver, el comando es bastante parecido al de ssh, de hecho, si no se tiene la clave publica del host (o si ha cambiado), hace lo que haria ssh ( y pedira la clave  del usuario )

Una  vez montada, se puede navegar por la carpeta como si fuera una normal

Desmontando una carpeta El comando para desmontar una carpeta es fusermount -u 

El unico parametro, Punto de montaje, sirve para especificar la carpeta donde se monto el SSHFS

Y ya esta!

[Referencias] http://tuxpepino.wordpress.com/

Hasta ahora!!