Rejilla abultada isométrica

Podemos abordar este problema de muchas maneras.

Usar una aplicación de trazado

El primer enfoque es obtener los datos originales y convertir la rotación en isométrica, usaría este enfoque. La imagen original probablemente esté hecha en matlab (y prefiero no lidiar con eso). Pero prefiero Mathematica porque, en mi opinión, hace mejores gráficos y, en este caso, es más agradable en general.

Lo más probable es que la función trazada sea xe ^{-(x 2 + y 2 )} . así que vamos a trazar eso. Con la ayuda de un poco de búsqueda en Google aquí para isometricView , obtenemos (escalé los ejes, volteé los datos, etc.):

foo = Plot3D[-2*x Exp[-(-x)^2 - y^2], 
   {x, -2, 2}, {y, -2, 2}, 
   PlotRange -> Full,
   ColorFunction -> "Rainbow",
   Boxed -> False, Axes -> False,
   PlotPoints -> 30,
   Mesh -> 10];
Show[foo, ViewMatrix -> isometricView[foo, {1, 1, 1}, {0, 0, 1}]]

Luego puede guardarlo como un PDF que se puede abrir en Illustrator o simplemente generar un archivo png. Esto resulta en:

Imagen 1 : Replot de la imagen.

Con unas pocas líneas más, puede hacer que el resultado sea completamente vectorial, si lo desea. Consulte Mathematica.SE .

Puede usar python con scipy para obtener el mismo resultado con bastante facilidad (sí, incluso la salida vectorial para líneas es posible nuevamente, algo de trabajo, no mucho más de 20 minutos de búsqueda en Google), así como matlab con un poco más de trabajo y así sucesivamente.

Trazado en illustrator

Bien, entonces podemos trazar en Illustrator usando un script de trazado gratuito de joojaa (sí, yo) llamado jooGraphFunctionque se encuentra aquí . La sugerencia para el gráfico isométrico se puede encontrar en la documentación.

Trazar la función paramétrica:

 x: 100*(+0.86605*0-0.86605*(t/100.))
 y: 100*(-0.5*0-0.5*(t/100.)-(t/100.)*exp(-(t/100.)*(t/100.)- (0*0)))
 Range -200 to 200 at step of 20

y obtienes:

Imagen 2 : Una línea dibujada

Repita la gráfica cambiando 0 a 0.5 y luego 1, 1.5, 2, -0.5, -1, -1.5 y -2

Imagen 3 : Una dirección hecha

Así que necesitamos dibujar las curvas en la dirección opuesta, la fórmula cambia a:

x: 100*(+0.86605*(t/100.)-0.86605*(0))
y: 100*(-0.5*(t/100.)-0.5*-0 - 0*exp(-(t/100.)*(t/100.)- (0*0)))

cambie nuevamente a 0.5 y luego 1, 1.5, 2, -0.5, -1, -1.5 y -2

Imagen 4 : Segunda dirección hecha. (Nota para agregar una opción de matriz a la GUI).

Bien, esto es un poco tedioso, pero obviamente funciona. Por lo tanto, sería mejor volver a implementar parte del script para que repita los datos en cuestión. Afortunadamente, la secuencia de comandos es modular, simplemente copie la última parte en un nuevo archivo de secuencia de comandos y piratee:

#target illustrator

// jooGraphFunctionLoopPlane.jsx  v0.9b modified for looping
//


for(var i=-2.0;i <= 2.0; i += 0.2 ){
     plotSmooth( -200, 20, 200, 0.01, PlotYfunc(i));
     plotSmooth( -200, 20, 200, 0.01, PlotXfunc(i));
}



function PlotYfunc(y) {
    return function(t){
    return new Array( 
        100*(+0.86605*(t/100.)-0.86605*y),
        100*(-0.5*(t/100.)-0.5*y - y*Math.exp(-(t/100.)*(t/100.)- (y*y))) );
    }

}

function PlotXfunc(x) {
    return function(t){
    return new Array( 
        100*(+0.86605*x-0.86605*(t/100.)),
        100*(-0.5*x-0.5*(t/100.) - (t/100.)*Math.exp(-(t/100.)*(t/100.)- (x*x))) );
    }

}

// this is a  very dirty and naive estimation 
function plotSmooth(start, step, end, delta, func){
    var doc = app.activeDocument;
    var path = doc.pathItems.add();

    var index = 0;

    for (var t = start;  t <= end + delta; t += step) {
        var point = path.pathPoints.add();

        now =  func(t);

        third = step / (3 * 2 * delta);

        t1 = func(t + delta);
        t2 = func(t - delta);


        tan1 = new Array(now[0]+(t2[0] - t1[0]) * third, now[1]+(t2[1] - t1[1]) * third)
        tan2 = new Array(now[0]-(t2[0] - t1[0]) * third, now[1]-(t2[1] - t1[1]) * third)        

        point.anchor = now;
        point.leftDirection = tan1;
        point.rightDirection = tan2;
    }
    return path;
}

Lo cual no es particularmente elegante pero funciona. Ahora podemos simplemente ajustar el ciclo for para tener cualquier cantidad de elementos de cuadrícula fácilmente, por lo que hacer una cuadrícula más densa no es más trabajo que cualquier otra cuadrícula:

Imagen 5 : cuadrículas generadas, simplemente cambie a la estructura de bucle