domingo, 24 de mayo de 2015

Ver mapa topográfico (con cotas o curvas de nivel) en Google Maps


Supongo que normalmente la forma de ver un mapa topográfico en Google Maps seria hacer lo que dice este video, desgraciadamente a mi no me funciona, de haberlo hecho no me hubiese puesto a escribir esta entrada. 

Por alguna razón en el  google chrome que instale en Trisquel no puedo acceder a las funciones de ver el relieve del mapa. Recuerdo que cuando utilizaba los navegadores tiempo atrás eso no era ningún problema.  ¿Era en Windows o en Linux?. Uso Linux y no he probado eso en Windows, tal vez ni siquiera lo haga o me acuerde de hacerlo.

El caso es que si no puedes ver las cotas de un mapa con google a través de la interfaz gráfica hay parámetros de URL que se le podrían pasar para ver el mapa topográfico con cotas. Por ejemplo, este link muestra un mapa con el pico de Naigutá en el centro y sin relieve:

https://www.google.co.ve/maps/@10.5398457,-66.7780024,14z?hl=es-419

Si se quiere ver el mapa con cotas y relieve basta con quitar el parámetro hl=es-419 y colocar el parámetro "data=!5m1!1e4" de esta forma:

https://www.google.co.ve/maps/@10.5398457,-66.7780024,14z/data=!5m1!1e4 

En este link se explica como utilizar los parámetros de URL de google chrome utilizando la sintaxis vieja, aunque recomendaría comenzar por los comentarios de stack overflow.  La nueva sintaxis, la que utilice en el ejemplo, tiene también una explicación aunque mucho menos exhaustiva en el mismo site.

Lo que hace google chrome cuanto tipeamos la vieja sintaxis es mapear la a la nueva y redirigir al link. Como se puede comprobar al colocar una dirección como esta:

http://maps.google.com/?ll=40.921555,-3.873539&spn=0.089888,0.181789&t=p&z=13

Me topé con este problema cuando buscaba una forma fácil de identificar todos los picos del Waraira Repano. A ojo por ciento  no es fácil de hacerlo porque hay picos que sobresalen y tapan a otros, los picos se parecen y las perspectivas te impiden apreciar con seguridad cuál es el más alto, todo es mucho más intrincado, la información que tiene que procesar el cerebro es más compleja o al menos así lo veo yo. Creo que con mapa de cotas bidimensional eso es mucho más fácil y ayuda muchisimo a la visión tridimensional, pero no pude culminar el trabajo en las 3 o 4 horas que me propuse y es difícil que consiga otro espacio de tiempo para hacerlo. Lo hacía por puro hobbie.

Publicado por en No hay comentarios:

miércoles, 20 de mayo de 2015

Colocar subtitulos de idioma a un video

Hay muchos videos que se puedes descargar por Internet, pero gran parte están en inglés. Por fortuna hay personas y páginas dedicadas a colocar los subtitulos a esos videos y que los difunden de forma completamente gratuita como la de difunde la palabra.  Estas traducción se almacenan es un archivo en formato de texto con extensión '.srt' . Hay varias formas de colocar los subtitulos a esos videos. Una de las herramientas que se utiliza para ello es mencoder, aunque la línea de comandos para hacerlo es bastante engorrosa y no es fácil de explicar, algo como esto:

$ mencoder -sub archivo_subtiulos.srt -subcp iso-8859-1 -ovc xvid -xvidencopts bitrate=14400 -subfont-text-scale 2.5 -oac pcm -o video_entrada.mp4 video_salidad.mp4

Además de lo difícil que es utilizarlo (la instrucción anterior no vale para todos los casos) mencoder es sumamente lento para colocar los subtitulos. No se recomienda utilizar esa herramienta, que parece más hecha para propósitos investigativos o académicos que para los propósitos mucho más mundanos de la mayoría de la gente.

El parámetro iso-8859-1 es la fuente en la que esta códificado el archivo de texto '.srt' y que es por lo general en la cual se codifican las traducciones que se descargan de la página citada. Para saber con seguridad cuál es la fuente en la que esta codificado el archivo se utiliza el comando file:

$ file nombre_archivo.X

Una forma mucho más sencilla y muchísimo más rápidad de colocar los subtitulos es con mkvmerge, esta es la que se recomienda.

$ mkvmerge -o video_salida.mkv video_entrada.mp4 --sub-charset 0:ISO-8859-1 -s 0 archivo_subtitulos.srt

Luego de traduccir 2 videos con esta instrucción no tuve problemas para ver los subtitulos en ninguno en los reproductores de video de Linux como VLC, ¡Y no tarda más de 5 segundos en comparación con mencoder que puede tardar hasta media hora para traducir un video de hora y media !!!. Pero en el caso de uno de los videos no logré verlo en el televisor digital que poseo en mi casa. Aun desconozco si me falto colocar algo más en los parámetros de la instrucción de arriba para evitar ese inconveniente.  Si lo descubro haré las correcciones pertinentes en esta entrada.


Publicado por en No hay comentarios:

jueves, 30 de abril de 2015

Alternativas Monetarias para Venezuela


Tengo que aclarar que no soy economista, sino informático y este blog hasta ahora ha estado centrado solo en los tópico de mi área específica. Sin embargo crear otro blog para verter las ideas y opiniones que voy a dar aquí es algo que me parece un desperdicio. Tengo otro blog pero es sobre  temas algo más raros y lo publico bajo seudónimo. Hasta ahora no he querido romper ese anonimato. Pero seria complemente errado suponer que los informáticos no estamos en la capacidad de opinar o razonar sobre temas como estos, los requerimientos del mundo actual nos obligan a ser expertos de negocio y el caso del dinero o la moneda no es una excepción como lo demuestra el origen de las actuales criptodivisas.

La otra razón que mi impulsa a escribir esta entrada es la terrible y  insufrible crisis que estamos atravesando los venezolanos,  la muy relativa paz y el silencio atronador con la cual la estamos sobrellevando muchos de nosotros. Asi que de momento voy a salirme de la línea del blog para comentar que alternativas monetarias tendríamos los venezolanos para salir de la crisis.

Nuestro país esta atravesando una crisis financiera. Con crisis financiera se quiere decir que el problema de raíz no es una crisis de escasez de recursos, que no es una crisis humanitaria sino básicamente una crisis del flujo del dinero y la entrada del dinero, los problemas derivan de eso.  Hay escasez de dólares, una alta demanda del mismo y una baja oferta de esa codiciada moneda, por otra parte los únicos que compran bolívares son los colombianos. Esta escasez de dólares es causada por el control monetario y la fuga de divisas.

Debemos entender que una moneda es un producto y que como tal esta sujeta a las leyes de la oferta y la demanda. Esto puede sonar extraño a algunos, pero no lo es. Una moneda es un producto basado en la confianza y la solidez del estado que la emite. El estado además le da un uso obligatorio a la moneda y hace necesaria su circulación con tan solo tasar sus tributos en la misma.

Básicamente el dólar sube porque hay una alta demanda del mismo y hay una alta demanda de dólares debido a la gran cantidad de importaciones que tiene el país. Nada más en lo que comemos se importa el 70%. El país importa, pero no produce. El flujo de dólares entrante proviene de las exportaciones de un recurso no renovable al cual la naturaleza le tomo millones de años producir, mientras que el hombre lo consumirá en apenas un par de siglos: el petróleo.

El problema de raíz de Venezuela es en realidad que no produce. Importa alimentos, vehiculos de transporte terrestre y aéreo, electrodomésticos, maquinaria pesada, repuestos para maquinaria, etc, todo, casi todo. Somos grandes consumistas y para seguir importando necesitamos dólares.  De allí la escasez de la divisa.

La escasez de dólares provoca la depreciación monetaria del bolívar y la escasez de los productos que importamos de forma directa o la escasez inducida por el cierre de las fábricas nacionales que a su vez dependen de los dólares para la compra de repuestos o insumos. 

El dólar se encarece y nuestra moneda cada vez vale menos hasta que llegamos al punto de cuestionarnos si realmente sigue teniendo sentido sequir usándola.

Además la depreciación monetara aupada al control cambiario y al control de precios trae aparejada una seria de distorsiones que en la actualidad son el flagelo de la economía venezolana:

  • El contrabando: se obtiene una altisima rentabilidad al llevarse los productos nacionales de forma ilegal, dado que el control de precios pone esto muy por debajo de los equivalentes en dólares en el mercado vecino. Las ganancias son multimillonarias.
  • Bachaqueo: comprar productos regulados por el control de precios para después venderlos más caros. 
  • Mercado negro de dólares: para el caso de Venezuela que es el que tratamos se dice que tiene su principal sede el Cúcuta, Colombia, el país que más se benecia del contrabando con Venezuela y cuya deflación no seria exagerado suponer que se debe en gran parte a la  merma e inflación de la economía venezolana.

Hay pocas alternativas que están sobre la mesa y que se podrían considerar para o bien sustituir la moneda o aumentar la apreciación de la misma. Entre estas alternativas están:

  • Dolarización 
  • Bolivarización del precio del petróleo
  • Moneda electrónica

Dolarización


Es la alternativa de la que más se ha hablado y la que parece más viable y atractiva de todas. Ha sido implementada con éxito en paises como Ecuador.







Bolivarización del precio del petróleo

De quien leí esta propuesta originalmente fue de Jairo Larotta en Aporrea. En su artículo el habla es de bolívares-oro no simplemente de bolívares. La propuesta original de Jairo no la he podido comprender del todo

























Publicado por en No hay comentarios:

miércoles, 29 de abril de 2015

X11 como usuario root o cualquier otro usuario

Muchos de los usuarios de linux se han sentido tentados alguna vez por ejecutar una aplicación gráfica desde la terminal en modo root o cualquier otro usario, pero se han encontrado con algo como esto:

.... cannot open display: :0.0

Si se trata de una aplicación java dira algo así:

java.lang.internalerror can't connect to X11 window server using ' 0.0' as the value of the DISPLAY variable

La forma más fácil de salir de esto seria mediante un: 

$ xhost +si:localuser:nombre_usuario 

También se podría modificar directamente los archivos involucrados en esto, aunque como era de suponer, es más tedioso, lo indico a modo de curiosidad. 

Para permitir que la aplicación se ejecute con el usuario activo en la consola se debe primero ubicar una clave en el directorio /var/run/xauth/ , allí se encuentra un archivo que se puede también conseguir con el comando:

$ find /var/run/xauth/A${DISPLAY}-*|tail -n1

Publicado por KENTNL, de cuyo blog extrage toda esta información . Luego de identificado el archivo (en mi máquina solo es uno), se debe imprimir y decodificar la clave con el comando:

$ sudo xauth -f /var/run/xauth/nombre_archivo  list

Lo cual mostrara algo como esto:

#ffff##:  MIT-MAGIC-COOKIE-1  711f067eae4ec73599dc38dbfaa164f0


Es casi obvio que 711f067eae4ec73599dc38dbfaa164f0 es la clave. Dentro del usuario en el cual queremos tener acceso tipearemos finalmente un comando como este: 

$ xauth add :0 MIT-MAGIC-COOKIE-1 711f067eae4ec73599dc38dbfaa164f0

El cual creara un archivo llamado .Xauthority en el directorio home del usuario logueado con las credenciales que le daran finalmente el acceso a X11. Si después se le quiere quitar acceso a X11 basta con borrar ese archivo. Desgraciadamente la clave cambia con cada reinicio de la computadora asi que si se quiere hacer este cambio permanente deben seguirse las recomendaciones del blog de KENTNL.


Publicado por en No hay comentarios:

viernes, 24 de abril de 2015

El Misterio del pase de parámetros en Java: ¿por valor o referencia?


Resulta sorprendente como después de llevar tiempo programando en Java y haber hecho infinidad de maravillas  uno se pueda quedar perplejo y hasta embarazado con la cuestión de si se pasan o no los parámetros por valor o referencia y cómo y cuándo. En un aula de clases no se le suelen dedicar ni dos horas ha hablar sobre eso.  De hecho en la Web existen diversidad opiniones sobre este tema, ¡pero no debería estar sujeto a opinión!, estamos hablando de algo que indiscutiblemente  tiene una implementación formal, de algo que esta programado y definido por el standar de Java por lo siglos de los siglos y que nadie puede cambiar ¿pero de cuál standar estamos hablando? ¿sera uno de estos? ¿o estos? ¿quién sera tan sesudo y paciente como para ponerse a revisarlos?. La polémica esta armada, vean la que se armo en stack overflow por este tema.

Parece que el problema esta en la forma en como hablamos. De hecho creo que eso de parámetros por valor y referencia es semánticamente confuso, pero Scott Stanchfield que es mucho más experto que yo, no esta de acuerdo con mi opinión, ni con la de muchos otros. Hablar de parámetros por valor y referencia no es algo muy típico de java o de los libros que tratan sobre java, no les extrañe si no consiguen nada sobre eso en muchos o no pocos de ellos.  Eso es algo más bien propio de lenguaje C. En java no se declara explicítamente parámetros por referencia o por valor, no existen por ejemplo los punteros , que es de donde viene esa distinción. Y sin embargo los parámetros implicítamente se pasan por valor o por referencia. Así que no es simplemente una extrapolación invalidad de los conocimientos de lenguaje C.

Un tema tan sencillo como este es algo que este link, parece haber cubierto plena y satisfactoriamente.  Lo dice y lo muestra muy claro:

"En Java todos los parámetros se pasan por valor
Cuando se realiza la llamada a un método, los parámetros formales reservan un espacio en memoria y reciben los valores de los parámetros actuales.
Cuando el argumento es de tipo primitivo (int, double, char, boolean, float, short, byte), el paso por valor significa que cuando se invoca al método se reserva un nuevo espacio en memoria para el parámetro formal. El método no puede modificar el parámetro actual.
Cuando el argumento es una referencia a un objeto (por ejemplo, un array o cualquier otro objeto) el paso por valor significa que el método recibe una copia de la dirección de memoria donde se encuentra el objeto. La referencia no puede modificarse pero sí se pueden modificar los contenidos de los objetos durante la ejecución del método"

En primer lugar lo que dice allí hecha por tierra que en Java se pasen parámetros por referencia y valor, dado que dice que solo se pasan por valor, y por tanto si se estaría extrapolando de forma invalidad los conceptos de lenguaje C. Pero antes de discutir eso vamos a ver cómo es que maneja java el pase de los parámetros.

Según ese link si los parámetros son primitivos la función tomará sus valores pero no podrá modificar el valor del parámetro original. Si los parámetros son objetos, la función podrá modificar los contenidos de los objetos.

Pero ¿qué pasa si los parámetros que se le pasan son arrays de primitivos? Efectivamente el link no dice nada sobre eso. Los arrays en Java son objetos aunque sean array de primitivos,  no es algo que sea obvio o haya que deducir (excepto programando), hay que saberlo.  Alguien que comento en Stack overflow dice que eso se especifica claramente en en la sección 4.3.1 de la Java Language Specification. 

Asi que si escriben:

char bb[] = {'s', 'o', 'p'};
if (bb instanceof Object) System.out.println("Yes!");

dira 'Yes!' .

Así que eso que se decía de que todos las clases de Java heredaban de Object es también cierto para los arrays primitivos.

Eso si, si escriben:

char bb[] = {'s', 'o', 'p'};
System.out.println("Nombre de Clase: " + bb.getClass().getName());

Les saldrá una cosa rara.

El link también decia que si se pasaban objectos a un método el contenido de estos podría ser modificado por el mismo. Por el contenido entiendo los atributos del objeto. Sin embargo hay ciertos objetos que sobrecargan el operador '=' (extrapolando la terminología de C++ dado que en Java en realidad no se sobrecargan los operadores) para lo eso no es cierto. Me refiero al objetos como String o Integer.

Si se hace:

String cadena = 'dsfskjlf';

luego se pasa como parámetro  a un método y allí se sustituye por otro valor eso no tendrá ningún efecto sobre el parámetro que se paso luego de salir del método. Parece que esto es cierto para todo Objecto que sobrecargue (extrapolando como dije antes) al operador '=', los cuales no son muchos.

Formalmente no se como se explicaría estas excepciones en Java, porque en general es cierto que si los atributos de un objeto que se paso como parámetro a un método se modifican en dicho método los cambios se mantendrán luego de salir del método. En el caso de String y Integer parece claro. aunque sea raro, que el valor que se le asiga a los mismos no constituye un atributo del objeto.

Para evitar las extrapolaciones con lenguje C, Java debe tener un lenguage complementamente propio y autosufienciente, en donde los casos que he mencionado anteriormente no induzcan la menor confusión. Sin duda que Java tiene eso, aunque no lo maneje a ese nivel y al parecer son muchos los que tienen ese problema. Quiero decir, por ejemplo, que encuentro incomodo,  referirme a casos como los anteriores sin hablar de parámetros por referencia y valor o referirme a algo como la sobrecarga que como se ha visto no serían terminos muy propios o apropiados para el  lenguaje Java. Incluso seria errado simplemente decir que en Java los parámetros siempre se pasan por valor, allí también se esta extrapolando. ¿Pero no refleja esta confusión también debilidades en el lenguaje Java?.

Concluyo finalmente con un código que de forma empírica muestra como maneja los parámetros Java. Con esto espero no volver a tener nuevamente esta confusión.


package misc;

/**
 * Programa que ilustra el pase de parámetros en Java
 * @author alexander
 */
public class PasoParametrosFunciones {
    public PasoParametrosFunciones () {
        int a=3;
        char c='a';
        byte e= (byte)11;
        System.out.println("Paso de valores primitivos: ");
        System.out.println("Valor antes de ejecutar la función: a = " +a + ", c = " +c + ", d =" + e);
        paso_primitivos (a, c, e );
        System.out.println("Valor despues de ejecutar la funcion: a = " +a + ", c = " +c + ", d =" + e);
       
        int aa[] = {1, 2, 7};
        char bb[] = {'s', 'o', 'p'};
       
        System.out.println("Paso de arrays primitivos: ");       
       
        System.out.println("Valor antes de ejecutar la función: aa[2] = " +aa[2] + ",bb[1] = " + bb[1]);       
        paso_array_primitivos (aa, bb);
        System.out.println("Valor despues de ejecutar la función: aa[2] = " +aa[2] + ",bb[1] = " + bb[1]);               
       
        System.out.println("Paso de Objectos: ");       
       
        String veronica = new String ("Veronica");
        Persona persona = new Persona("Carlos Fuentes", 'M', 21);
        Integer v = 4333;
       
        System.out.println("Valor antes de ejecutar la función: String veronia = " +veronica + ", Entero v " + v +
                ", Nombre Persona = " + persona.getNombre() + ", Edad Persona = " + persona.getEdad());

        paso_objectos (veronica, persona, v);
        System.out.println("Valor antes de ejecutar la función: String veronia = " +veronica + ", Entero v " + v +
                ", Nombre Persona = " + persona.getNombre() + ", Edad Persona = " + persona.getEdad());
   
    }
    static public void main(String args[]) {
        new PasoParametrosFunciones ();
    }
    void paso_primitivos (int a, char c, byte e) {
        a=199; c='3'; e= (byte) 'f';
    }
    void paso_array_primitivos (int aa[], char bb[]) {
        aa[0]= 7;
        aa[1]= 99;
       
        aa[2]= 88;
       
        bb[0]= 'z';
        bb[1] ='b';
        bb[2] = 'i';
    }
    void paso_objectos(String nombre, Persona p, Integer aa) {
        nombre= "Laura";
        p.setNombre("Jaimito");
        p.setEdad(1000);
        aa = 821;
       
    }
}

class Persona {
    private String nombre;
    private char sexo;
    private int edad;
   
    public Persona(String nombre, char sexo, int edad) {
        this.nombre = nombre;
        this.sexo= sexo;
        this.edad = edad;
       
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public char getSexo() {
        return sexo;
    }

    public void setSexo(char sexo) {
        this.sexo = sexo;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
   
}
Publicado por en No hay comentarios:

Ghost Effect con la programación script de GIMP (script-fu)

Para GIMP se pueden hacer scripts que automaticen tareas que se hacen desde la interfaz gráfica. Por ejemplo, el siguiente script esta hecho para correr desde bash. Lo que hace es tomar un conjunto de imágenes que representan una secuencia animada y tomando una imagen como fondo transparenta el conjunto imagenes animadas sobre dicho fondo, creando lo que se conoce como un ghost effect. Las imagenes que se utilizen para ello deberán haberse tomado previamente sin mover la cámara y utilizando una imagen como fondo en un escenario vacio y sin nada animado, que este en la misma posición en la cuál se toman la secuencia de imagenes animadas. De otra forma lo que se obtendra es un revoltijo.

#!/bin/bash
# Script para crear animaciones que trabaja con dos capas
# - Una en la que hay un fondo estático
# - Y otra de la animación la cual se transparenta contra el fondo
# El resultado es aspecto fantasmal de la imagen animada.
# Tanto el fondo estático como la capa animada deben tomarse en la misma posición y sin mover la cámara

{
cat <<EOF
(define (crea-transparencia imagen_fondo imagen_animacion imagen_salidad)
  (let* (
     (image (car (gimp-file-load RUN-NONINTERACTIVE imagen_fondo imagen_fondo)))
     (layer nil)
         (drawable nil)
     )

    (set! layer (car (gimp-file-load-layer RUN-NONINTERACTIVE image imagen_animacion)))
   

    (gimp-image-add-layer image layer 0 )
    (gimp-layer-set-opacity layer 25)
    (set! drawable (car (gimp-image-merge-visible-layers image EXPAND-AS-NECESSARY)))
    (file-jpeg-save RUN-NONINTERACTIVE image drawable imagen_salidad imagen_salidad 1 0 0 0 " " 0 1 0 1)
    (gimp-image-delete image) ; ... o la memoria explotara
    )
  )

(gimp-message-set-handler 1) ; Messages to standard output
EOF

imagen_fondo="../00554/0531.jpg"

for i in ../00554/*.jpg; do
  imagen_salidad=`echo $i | cut -d '/' -f 3`
  echo "(gimp-message \"$i\")"
  echo "(crea-transparencia \"$imagen_fondo\" \"$i\" \"$imagen_salidad\")"
done

echo "(gimp-quit 0)"
} | gimp -i -b -


Este es un ejemplo de un video que desarrolle para un proyecto en la universidad hace un tiempo:


Publicado por en No hay comentarios:

domingo, 8 de marzo de 2015

Programación Gráfica en Linux


Programación a nivel de lenguaje C


Este es un programa sobre el conjunto Mandelbrot  extraido de esta página, que no daba ningún detalle de cómo compilarlo. Para poder compiarlo deben descargarse las librerias de OpenGL y Glut, el paquete de build-essentials y utilizar la instrucción:

$ gcc -o maldenbrot.o maldenbrot.c -lGL -lglut -lm




// Compilar con gcc -o maldenbrot.o maldenbrot.c -lGL -lglut -lm
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

void set_texture();

typedef struct {unsigned char r, g, b;} rgb_t;
rgb_t **tex = 0;
int gwin;
GLuint texture;
int width, height;
int tex_w, tex_h;
double scale = 1./256;
double cx = -.6, cy = 0;
int color_rotate = 0;
int saturation = 1;
int invert = 0;
int max_iter = 256;

void render()
{
    double    x = (double)width /tex_w,
        y = (double)height/tex_h;

    glClear(GL_COLOR_BUFFER_BIT);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

    glBindTexture(GL_TEXTURE_2D, texture);

    glBegin(GL_QUADS);

    glTexCoord2f(0, 0); glVertex2i(0, 0);
    glTexCoord2f(x, 0); glVertex2i(width, 0);
    glTexCoord2f(x, y); glVertex2i(width, height);
    glTexCoord2f(0, y); glVertex2i(0, height);

    glEnd();

    glFlush();
    glFinish();
}

int dump = 1;
void screen_dump()
{
    char fn[100];
    int i;
    sprintf(fn, "screen%03d.ppm", dump++);
    FILE *fp = fopen(fn, "w");
    fprintf(fp, "P6\n%d %d\n255\n", width, height);
    for (i = height - 1; i >= 0; i--)
        fwrite(tex[i], 1, width * 3, fp);
    fclose(fp);
    printf("%s written\n", fn);
}

void keypress(unsigned char key, int x, int y)
{
    switch(key) {
    case 'q':    glFinish();
            glutDestroyWindow(gwin);
            return;
    case 27:    scale = 1./256; cx = -.6; cy = 0; break;

    case 'r':    color_rotate = (color_rotate + 1) % 6;
            break;

    case '>': case '.':
            max_iter += 128;
            if (max_iter > 1 << 15) max_iter = 1 << 15;
            printf("max iter: %d\n", max_iter);
            break;

    case '<': case ',':
            max_iter -= 128;
            if (max_iter < 128) max_iter = 128;
            printf("max iter: %d\n", max_iter);
            break;

    case 'c':    saturation = 1 - saturation;
            break;

    case 's':    screen_dump(); return;
    case 'z':    max_iter = 4096; break;
    case 'x':    max_iter = 128; break;
    case ' ':    invert = !invert;
    }
    set_texture();
}

void hsv_to_rgb(int hue, int min, int max, rgb_t *p)
{
    if (min == max) max = min + 1;
    if (invert) hue = max - (hue - min);
    if (!saturation) {
        p->r = p->g = p->b = 255 * (max - hue) / (max - min);
        return;
    }
    double h = fmod(color_rotate + 1e-4 + 4.0 * (hue - min) / (max - min), 6);
#    define VAL 255
    double c = VAL * saturation;
    double X = c * (1 - fabs(fmod(h, 2) - 1));

    p->r = p->g = p->b = 0;

    switch((int)h) {
    case 0: p->r = c; p->g = X; return;
    case 1:    p->r = X; p->g = c; return;
    case 2: p->g = c; p->b = X; return;
    case 3: p->g = X; p->b = c; return;
    case 4: p->r = X; p->b = c; return;
    default:p->r = c; p->b = X;
    }
}

void calc_mandel()
{
    int i, j, iter, min, max;
    rgb_t *px;
    double x, y, zx, zy, zx2, zy2;
    min = max_iter; max = 0;
    for (i = 0; i < height; i++) {
        px = tex[i];
        y = (i - height/2) * scale + cy;
        for (j = 0; j  < width; j++, px++) {
            x = (j - width/2) * scale + cx;
            iter = 0;

            zx = hypot(x - .25, y);
            if (x < zx - 2 * zx * zx + .25) iter = max_iter;
            if ((x + 1)*(x + 1) + y * y < 1/16) iter = max_iter;

            zx = zy = zx2 = zy2 = 0;
            for (; iter < max_iter && zx2 + zy2 < 4; iter++) {
                zy = 2 * zx * zy + y;
                zx = zx2 - zy2 + x;
                zx2 = zx * zx;
                zy2 = zy * zy;
            }
            if (iter < min) min = iter;
            if (iter > max) max = iter;
            *(unsigned short *)px = iter;
        }
    }

    for (i = 0; i < height; i++)
        for (j = 0, px = tex[i]; j  < width; j++, px++)
            hsv_to_rgb(*(unsigned short*)px, min, max, px);
}

void alloc_tex()
{
    int i, ow = tex_w, oh = tex_h;

    for (tex_w = 1; tex_w < width;  tex_w <<= 1);
    for (tex_h = 1; tex_h < height; tex_h <<= 1);

    if (tex_h != oh || tex_w != ow)
        tex = realloc(tex, tex_h * tex_w * 3 + tex_h * sizeof(rgb_t*));

    for (tex[0] = (rgb_t *)(tex + tex_h), i = 1; i < tex_h; i++)
        tex[i] = tex[i - 1] + tex_w;
}

void set_texture()
{
    alloc_tex();
    calc_mandel();

    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, 3, tex_w, tex_h,
        0, GL_RGB, GL_UNSIGNED_BYTE, tex[0]);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    render();
}

void mouseclick(int button, int state, int x, int y)
{
    if (state != GLUT_UP) return;

    cx += (x - width / 2) * scale;
    cy -= (y - height/ 2) * scale;

    switch(button) {
    case GLUT_LEFT_BUTTON: /* zoom in */
        if (scale > fabs(x) * 1e-16 && scale > fabs(y) * 1e-16)
            scale /= 2;
        break;
    case GLUT_RIGHT_BUTTON: /* zoom out */
        scale *= 2;
        break;
    /* any other button recenters */
    }
    set_texture();
}


void resize(int w, int h)
{
    printf("resize %d %d\n", w, h);
    width = w;
    height = h;

    glViewport(0, 0, w, h);
    glOrtho(0, w, 0, h, -1, 1);

    set_texture();
}

void init_gfx(int *c, char **v)
{
    glutInit(c, v);
    glutInitDisplayMode(GLUT_RGB);
    glutInitWindowSize(640, 480);
    glutDisplayFunc(render);

    gwin = glutCreateWindow("Mandelbrot");

    glutKeyboardFunc(keypress);
    glutMouseFunc(mouseclick);
    glutReshapeFunc(resize);
    glGenTextures(1, &texture);
    set_texture();
}

int main(int c, char **v)
{
    init_gfx(&c, v);
    printf("keys:\n\tr: color rotation\n\tc: monochrome\n\ts: screen dump\n\t"
        "<, >: decrease/increase max iteration\n\tq: quit\n\tmouse buttons to zoom\n");

    glutMainLoop();
    return 0;
}

Publicado por en No hay comentarios:
Suscribirse a: Entradas (Atom)