Paquete_Plots.ipynb

{
    "cells": [
    {
 	    "cell_type": "markdown", 
 	    "source": [ 
 		"# Paquete Plots" 
 	    ], 
 	    "metadata": {} 
	},
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tusing Pkg; Pkg.activate(\".\"); Pkg.instantiate()\n",
                "\tusing Pkg; Pkg.activate(\".\"); ##Pkg.add(\"Plots\") \n",
                "\tusing Plots\n",
                "\ttheme(:wong)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 533
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "## Plots.jl\n",
                "Plots.jl es un paquete en Julia que permite realizar diferentes tipos de trazados o gráficos, sin embargo, no es un paquete que realiza el trazado de forma estricta. Lo anterior significa que **Plots.jl es un metapaquete y constituye una interfaz entre diferentes paquetes de trazado**, simplificando trabajar con dichos paquetes.\n",
                "\n",
                "Que Plots.jl sea un metapaquete es una ventaja, ya que solamente se necesita aprender la forma en que se realiza gráficos con Plots.jl y no las particularidades de los paquetes para realizar gráficos.\n",
                "\n",
                "Por tanto, con Plots.jl es posible utilizar el mismo código para trabajar con diferentes paquetes de trazado. Los paquetes de trazado, en Plots.jl, se conocen como   'backends' de los cuales se pueden mencionar:\n",
                "+ [GR](https://gr-framework.org/about.html)\n",
                "+ [PlotlyJS](https://plotly.com/julia/)\n",
                "+ [PyPlot](https://github.com/JuliaPy/PyPlot.jl)\n",
                "+ [PGFPlotsX](https://kristofferc.github.io/PGFPlotsX.jl/stable/index.html)\n",
                "+ [UnicodePlots](https://github.com/Evizero/UnicodePlots.jl)\n",
                "\n",
                "Para conocer con cuál de los backends se está trabajando se utiliza la función `backend`:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "backend()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 534
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Pero, ya que se necesita correr de fondo un backend es necesario que éste sea instalado de la forma usual (`Pkg.add('nombre_backend')`) y sea invocado mediante una función que implementa `Plots.jl`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "##Pkg.add(\"GR\");\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 535
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "##Pkg.add(\"Plotly\");\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 536
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Activar un backend se realiza de la siguiente forma:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tplotly()\n",
                "\tbackend();\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 537
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tgr()\n",
                "\tbackend();\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 538
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Comandos básicos\n",
                "El comando más básico cuando se usa Plots.jl es `plot`. El comando `plot` admite diversas formas argumentos entrantes y dependiendo del caso se obtiene un determinado comportamiento.\n",
                "\n",
                "Al igual que muchas funciones definidas en Julia, existe la versión mutante (`plot!`). La versión mutante permite modificar una determinada gráfica, añadiendo atributos u otro trazado.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tx₁ = -10:0.1:10\n",
                "\ty₁ = x₁.^2\n",
                "\tplot₁ = plot(x₁,y₁)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 539
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los argumentos de `plot` son dos array: el primero `x₁`, constituye el eje horizontal; el segundo `y₁` constituye el eje vertical. En `plot₁` hay solo una serie graficada.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tx₂ = -10:0.1:10\n",
                "\tseries₂ = [100x₂.^2 5x₂.^3]\n",
                "\tplot₂ = plot(x₂, series₂)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 540
        },
        {
            "cell_type": "markdown",
            "source": [
                " \n",
                "En el ejemplo anterior son graficadas dos series, los datos para cada serie están contenidos en las columnas de un array de dos dimensiones (en general, las columnas de un array serán interpretadas como series de datos). \n",
                "\n",
                "A esta gráfica se le pueden añadir más series, para ello se utiliza la versión mutante de `plot`. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot!(x₂, x₂.^4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 541
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "La función mutante `plot!` actúa sobre la gráfica actual: `Plots.CURRENT_PLOT`, por ahora la gráfica actual es `plot₂`. La gráfica actual puede ser consultada mediante la función `current()`. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "current()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 542
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para que `plot!` actúe sobre un gráfico en específico, este debe ser pasado como argumento.\n",
                "\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot!(plot₁, x₁, x₁.^3)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 543
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Ahora la gráfica actual es plot₁ modificada.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "current()\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 544
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para hacer una gráfica en el REPL de Julia se puede utilizar el backend `unicodeplots()`.\n",
                "\n",
                "Si se desea realizar una gráfica de 3 dimensiones, se pasa como parámetros tres arrays con los valores a graficar.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tplot3d = plot(1:10,1:10,(1:10).^2)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 545
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Atributos de los gráficos\n",
                "Es natural que se desee agregar estilo a los gráficos, es decir, modificar o agregar: título, etiquetas a los ejes, controlar las marcas en el eje, etc. Todo lo anterior es manejado a través de atributos.\n",
                "\n",
                "Los atributos se pueden pasar al gráfico de diferentes maneras:\n",
                "+ Mediante la declaración explícita con `atributo = valor`.\n",
                "+ Usando la función implementada al atributo `atributo!(valor)`.\n",
                "En caso que se utilice la función es importante recordar que, como con `plot!`, se puede declarar de forma explícita la gráfica al cual se quiere modificar su atributo; si la gráfica no es declarada, se modifica la gráfica actual. \n",
                "\n",
                "Los atributos pueden estar relacionados con: las gráficas ([Plot](http://docs.juliaplots.org/latest/generated/attributes_plot/##Plot)), las series ([Series](http://docs.juliaplots.org/latest/generated/attributes_series/#Series)), subgráficas ([Subplot](http://docs.juliaplots.org/latest/generated/attributes_subplot/#Subplot)) y los ejes ([Axis](http://docs.juliaplots.org/latest/generated/attributes_axis/#Axis)). En el REPL los diferentes atributos, pueden ser consultados mediante:\n",
                "+ `plotattr(:Plot)`\n",
                "+ `plotattr(:Series)`\n",
                "+ `plotattr(:Subplot)`\n",
                "+ `plotattr(:Axis)`\n",
                "Con los comandos anteriores solo se obtienen los nombres o alias de los atributos disponibles. Si se conoce el alias del atributo, se puede utilizar la función `plotattr` para obtener una descripción de ese atributo.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los atributos de las gráficas, pueden ser consultados [aquí](http://docs.juliaplots.org/latest/generated/supported/##Keyword-Arguments). A continuación, se describen atributos que son usualmente usados.\n",
                "\n",
                "#### Leyenda\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tx₃ = -2pi:0.1:2pi\n",
                "\tplotp₃ = plot(x₃, [sin, cos], label=[\"f₁(x)=sin(x)\" \"f₂(x)=cos()\"])\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 546
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El atributo `label` permite nombrar cada serie de datos, apareciendo dicho nombre en la leyenda. Se pueden utilizar también palabras claves para referirse a los atributos, en el caso de `label` se puede usar: `lab` o `labels`. A diferencia de otros atributos, `label`, se declara cuando el gráfico es creado en la primera ocasión.\n",
                "\n",
                "Las leyendas: el color, tamaño, tipo de letra y ubicación; puede ser modificado con los atributos: `legendfontcolor`, `legendfontsize`, `legendfont` y `legend`. El atributo `legend` acepta los siguientes valores: `:none`, `:best`, `:inline`, `:inside`, `top`, `bottom`, `left`, `right`; también acepta las siguientes combinaciones: `:(outer ?)(top/bottom ?)(right/left ?)`.\n",
                "\n",
                "Para obtener una mejor tipografía se puede utilizar el paquete 'LaTeXStrings', el cual permite escribir fórmulas matemáticas con el estilo de LaTeX.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\t##Pkg.add(\"LaTeXStrings\")\n",
                "\tusing LaTeXStrings\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 547
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tplot₃ = plot(x₃, [sin, cos], label=[L\"f_1(x)=sin(x)\"  L\"f_2(x)=cos(x)\"], legend=:topright, legendfontcolor=:gray, legendfontsize=10)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 548
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Título\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "title!(plot₃,L\"\\textbf{Gráficas de } sin(x) \\, \\textbf{y} \\, cos(x)\", titlefontsize=20, titlefontcolor=:gray)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 549
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "El atributo `title` de utiliza para cambiar el nombre de la gráfica. Los atributos: `titlefontsize` y `titlefontcolor` modifican el tamaño y el color del título de la gráfica.\n",
                "\n",
                "#### Ejes\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot!(plot₃, xlabel=L\"\\textbf{x}\", ylabel=L\"\\textbf{y}\") \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 550
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los atributos `xlabel` y `ylabel` se utilizan para etiquetar los ejes respectivamente. Si el gráfico fuera en tres dimensiones se puede etiquetar el eje de la tercera dimensión con `zlabel`. \n",
                "\n",
                "Note que los atributos pueden ser modificados o agregados con la función `plot!`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot!(plot₃, xticks=(-2π:π:2π, [\"-2π\",\"-π\",\"0\",\"π\",\"2π\"]), xlims=(0,2π), xtickfontsize=10) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 551
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el ejemplo anterior se modifican las etiquetas de las marcas del eje $x$, para ello se utiliza el atributo `xticks`, el cual recibe como valor la secuencia de números que constituirán las marcas. En caso de querer etiquetar las marcas con alguna etiqueta personalizada, al atributo `xticks` se pasa una tupla conteniendo la secuencia y una lista de las marcas personalizadas.\n",
                "\n",
                "Note que apesar que la gráfica se ha definido para ser graficada de `-2π` a `2π`, solamente se ha graficado de `0` a `2π`, ello es posible al indicar los límites del eje $x$ con el atributo `xlims` que recibe una tupla conteniendo el límite inferior y superior. \n",
                "\n",
                "Aunque no se mostrará, el eje $y$ y el eje $z$ (en caso que la gráfica sea de 3 dimensiones) puede ser modificado de manera similar que el eje $x$. La diferencia será que, en lugar de colocar `x` antes de `ticks` o `lims` se deberá colocar el eje que se desea modificar (`y` o `z`).\n",
                "\n",
                "Con el atributo `xtickfontsize` se modifica el tamaño de las etiquetas de las marcas del eje $x$; como se explica en el párrafo anterior se puede modificar el eje $y$ y $z$.\n",
                "\n",
                "#### Grilla\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot!(plot₃, gridlinewidth=4, gridcolor=:red, gridalpha=0.2, gridstyle=:dashdotdot)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 552
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "La grilla puede ser modificada con los atributos: `gridlinewidth`, `gridcolor`, `gridalpha`,`gridstyle` (acepta los valores `:solid`, `:dash`, :`dot`, `:dashdot`, `:dashdotdot`), que modifican respectivamente: el ancho de las líneas de la grilla, el color de la grilla, la intensidad del color de la grilla (por defecto se transparenta) y el estilo de las líneas de la grilla.\n",
                "\n",
                "Si no se desea que la grilla aparezca, se debe asignar el valor de `false` al atributo  `grid` (por defecto es `true`).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot!(plot₃, grid=false)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 553
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Otros\n",
                "Para definir los atributos y por tanto el estilo de la gráfica una sola vez, en lugar de hacerlo cada ocasión que la gráfica que se construya, se puede utilizar la función `default`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tcolor = RGBA(190/255, 190/255, 190/255,1)\n",
                "\tdefault(titlefontsize=20, titlefontcolor=color, tickfontcolor=color, tickfontsize=9, legendfontcolor=color)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 554
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Tipos de serie\n",
                "\n",
                "En todos los ejemplos anteriores se han graficado líneas (serie `:line`), para graficar un tipo específico, éste puede ser especificado mediante el atributo `seriestype`.\n",
                "\n",
                "El atributo `seriestype` admite símbolos, que representan los diferentes tipos de gráficos o series. A continuación, se listan algunos tipos de serie:\n",
                "+ `:line`\n",
                "+ `:scatter`\n",
                "+ `:histogram`\n",
                "+ `heatmap`\n",
                "+ `:image`\n",
                "\n",
                "Pueden existir algunos tipos de series que no sean soportados por algunos backends, para conocer cuáles tipos de series son soportados por los backends, puede leer sobre ello [aquí](http://docs.juliaplots.org/latest/generated/supported/##supported)\n",
                "\n",
                "Para cada serie, el paquete incorpora una función que llama directamente  al tipo de serie y recibe el mismo nombre de la serie. También, incorpora una versión mutante y no mutante de dichas funciones. \n",
                "\n",
                "#### Serie `:line`\n",
                "Esta es la serie por defecto y la que une cada punto graficado con una línea.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot(rand(1:100,30), title=\"Serie `line`\", seriestype=:line)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 555
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot₄ = plot(rand(1:100,30), title=\"Serie `line`\", markershape=:circ, linewidth=3, linecolor=:blue, linestyle=:dashdot, linealpha=0.5)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 556
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el ejemplo se muestra cómo personalizar la línea que es trazada, esto es, personalizar: el ancho de la línea, el color, el estilo de la línea y la transparencia de esta, mediante los atributos:  `linewidth`, `linecolor`, `linestyle` y `linealpha` respectivamente. Los estilos de las líneas admitidos, ya fueron mencionados cuando se discutía el atributo `grid`.\n",
                "\n",
                "En este último ejemplo, también se grafican los puntos que componen a la gráfica, más detalles sobre los atributos de las marcas se discuten en la siguiente sección.\n",
                "\n",
                "#### Serie `:scatter`\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot([rand(20) rand(20) rand(20)], seriestype=:scatter, title=\"Serie 'scatter'\", markershape=[:rect :circ :hex])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 557
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot₅ = scatter([rand(20) rand(20) rand(20)], title=\"Serie 'scatter'\", markershape=[:star  :diamond :ltriangle], markerstrokecolor=:red, markercolor=[:orange :green :darkblue], markeralpha=[0.5 1 0.2],  markersize= [3 7 12])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 558
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En los ejemplos anteriores han sido realizados graficos de dispersión. Para dar estilo al gráfico, se han añadido atributos que personalizan las marcas que representan los datos. \n",
                "\n",
                "`makershape` es el atributo que permite modificar la forma de la marca, para saber las distintas formas admitidas puede revisar este [enlace](http://docs.juliaplots.org/latest/generated/supported/##Markers). `markerstrokecolor`\n",
                "permite modificar el color del borde de la marca. `markercolor` permite modificar el color de la marca. `markeralpha` permite agregar transparencia al color de la marca. `markersize` permite modificar el tamaño de la marca. Para conocer el resto de atributos relacionados con los gráficos de dispersión, puede revisar el siguiente [enlace](http://docs.juliaplots.org/latest/attributes/##marker).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Serie `:histogram`\n",
                "\n",
                "Con esta serie es posible crear histogramas.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                " plot(rand(1:20,50), title=\"Serie 'histogram'\",seriestype=:histogram)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 559
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot₆ = histogram(rand(1:20,100), title=\"Serie 'histogram'\", normalized=true, bins=(0:21), orientation=:v, bar_width=1, color=[:red,:orange,:green], xticks=(1.5:21.5,[\"$i\" for i ∈ 1:20]), legend=:none)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 560
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para esta serie, los siguientes atributos aplican: `normalized`, que permite la altura de las barras se encuentre entre los valores 0 y 1; `bins`, permite indicar los valores de las etiquetas del eje $x$ y finalmente las barras que serán graficadas; `orientation`, permite graficar las barras de forma vertical  u horizontal; `bar_width`, permite modificar el ancho de la barra; `color`, permite graficar las barras con diferentes colores.\n",
                "\n",
                "En el ejemplo se utiliza el atributo `xticks` para modificar las etiquetas asociada a cada gráfica.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Serie `:heatmap`\n",
                "Con esta serie se pueden crear mapas de calor.  Para ello, se especifican los puntos del plano pasando como parámetros los puntos del eje $x$ y $y$, además, se pasa como parámetro una matriz (array) que define un valor numérico para cada punto del plano que es graficado en el mapa de calor.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot(1:10, 1:10, [i*y for i ∈ 1:10, y ∈ 1:10], title=\"Serie 'heatmap'\", seriestype=:heatmap)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 561
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot₇ = heatmap(1:0.03:10, 1:0.03:10, [i*y for i ∈ 1:0.03:10, y ∈ 1:0.03:10], title=\"Serie 'heatmap'\", color=cgrad([:black, :orange, :red, :blue]))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 562
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el ejemplo anterior se utiliza el atributo `color` para establecer el color del mapa de calor. La función `cgrad` permite crear nuesta propia paleta de colores, aunque Julia incorpora paletas y gradientes decolores, más de ello puede conocer [aquí](http://docs.juliaplots.org/latest/generated/colorschemes/##Colorschemes).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Serie `:image`\n",
                "Una imagen puede mostrarse con la serie `image`. Para cargar la imagen en el proyecto se puede hacer con el método `load` del paquete `Images`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "## Pkg.add(\"Images\"); Pkg.add(\"ImageMagick\");\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 563
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "using Images\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 564
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin\n",
                "\tim = load(\"images/julia.jpg\")\n",
                "\tplot₈ = plot(im, seriestype=:image, title=\"Serie 'image'\", ticks=false)\n",
                "end\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 565
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Creando subgráficas\n",
                "Las librerías de trazado, por lo general implementan formas de combinar varias gráficas como subgráficas. Con el paquete Plots se pueden crear diversos diseños, siendo el más sencillo de utilizar el diseño de malla o grilla.\n",
                "\n",
                "El diseño puede ser creado asignando una tupla, con las dimensiones de la grilla, al atributo `layout`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "plot(plot₆, plot₇, layout=(2,1))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 566
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Diseños más complejos pueden ser creados con la macro `@layout`, para más información revisar [Layouts](http://docs.juliaplots.org/latest/layouts/##Advanced-Layouts). \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Guardando una gráfica\n",
                "Para obtener una imagen con la gráfica realizada, se utiliza la función `savefig`, los argumentos que admiten son: \n",
                "+ El nombre con el que se desea guardar la imagen, junto con la extensión.\n",
                "+ El gráfico que se desea guardar. Si no se especifica el gráfico, se guarda el gráfico actual (`Plots.CURRENT_PLOT`).\n",
                "Hay que tener en cuenta que la extensión del archivo a guardar, depende del backend que se está usando ya que no todos admiten la misma extensión.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Referencias e información adicional\n",
                "\n",
                "El paquete de Julia ha sido extendido, en su funcionalidad y aplicación, mediante el desarrollo de diferentes paquetes que constituyen un entorno muy completo para los gráficos, una revisión rápida del ambiente de Julia para gráficos puede encontrarlo [aquí](http://docs.juliaplots.org/latest/ecosystem/).\n",
                "\n",
                "Referencias e información interesante puede encontrar en los siguientes enlaces:\n",
                "+ [Ejemplos de diferentes tipos de gráficas](https://github.com/JuliaPlots/ExamplePlots.jl/tree/master/notebooks)\n",
                "+ [Visualizing Graphs in Julia using Plots and PlotRecipes](http://www.breloff.com/Graphs/)\n",
                "+ [How do Recipes actually work?](https://daschw.github.io/recipes/)\n",
                "+ [Introducing Julia/Plotting](https://en.wikibooks.org/wiki/Introducing_Julia/Plotting)\n",
                "\n"
            ],
            "metadata": {}
        }
    ],
    "nbformat_minor": 2,
    "metadata": {
        "language_info": {
            "file_extension": ".jl",
            "mimetype": "application/julia",
            "name": "julia",
            "version": "1.5.1"
        },
        "kernelspec": {
            "name": "julia-1.5",
            "display_name": "Julia 1.5.1",
            "language": "julia"
        }
    },
    "nbformat": 4
}