Part_6_Plots/Julia_Plots.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='text-align: center'><a href=https://www.biozentrum.uni-wuerzburg.de/cctb/research/supramolecular-and-cellular-simulations/>Supramolecular and Cellular Simulations</a> (Prof. Fischer)<br>Center for Computational and Theoretical Biology - CCTB<br>Faculty of Biology, University of Würzburg</p>\n",
    "\n",
    "<p style='text-align: center'><br><br>We are looking forward to your comments and suggestions. Please send them to: <br><br></p>\n",
    "    \n",
    " <p style='text-align: center'>   <a href=andreas.kuhn@uni.wuerzburg.de>andreas.kuhn@uni.wuerzburg.de</a> or <a href=sabine.fischer@uni.wuerzburg.de>sabine.fischer@uni.wuerzburg.de</a></p>\n",
    "\n",
    "<h1><p style='text-align: center'> Introduction to Julia </p></h1>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This lesson will give you an introduction into the `Makie` package for visualizations in Julia. `Makie` is a very powerful data visualization library written in and for Julia. So far, `Makie` supports four different backends, each serving a different purpose. \n",
    "\n",
    "`CairoMakie` is the one used in this lesson. It excels in producing inline static 2D plots for scientific purposes. \n",
    "\n",
    "`GLMakie` is the second most important backend. `GLMakie` displays plots in a seperate gpu-rendered window. This makes it less convenient for static plots but comes with the benefit of a much higher performance. Therefore, it is well suited for dynamic and complex visualizations like videos, gifs or interactive animations. \n",
    "\n",
    "`WGLMakie` is very similar to `GLMakie`, with the difference that it is running inside a browser, sacrificing some speed towards better portability and compatibility. \n",
    "\n",
    "`RPRMakie` is an experimental backend to use raytracing on your GPU. It is quite early in development but can already create beautfiul images: \n",
    "\n",
    "\n",
    "<div>\n",
    "<img src=\"raytracing.png\" width=\"600\"/>\n",
    "</div>\n",
    "\n",
    "Tipp: For more beautiful images and examples created with `Makie` visit the page : https://lazarusa.github.io/BeautifulMakie/\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to make plots with Makie, you have to install and then import the backend you want to use. In this case, this would be  `CairoMakie`. \n",
    "All commands that you will learn in this lesson, will also work in `GlMakie` and `WGLMakie`, but the created plots might be in a different format. `RPRMakie` is a little bit more complicated, so for now just be aware of its existence ;). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using CairoMakie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Line Plot - Quick and Dirty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make a standard line plot, the function `lines()` can be used. A line plot is defined by x and y value pairs. These have to be given in the form of arrays or iterables. One array/iterable for all the x-values and another for all y-values. The x- and y-arrays need to be of the same size. \n",
    "The x-values can be omitted, then the y-values are plotted against the iterator `1:length(y-values)`. \n",
    "\n",
    "You can assign our plot to a variable. To invoke the plot you can use the `display(plot_name)` function. If the plot is created or called in the last line in a notebook cell, it gets displayed automatically.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: The first plot in Makie ( also in any other plotting package) can take much more time than the following plots. This is due to the JIT-Complier (Just in Time) of Julia and it is a well known [problem]( https://www.google.com/search?client=firefox-b-e&q=julia+first+time+to+plot). But this has been significantly improved with Julia 1.9.0 and above. So if you are still running an older version of Julia, it is time to upgrade ;).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input = [5,7,10,14]\n",
    "f = lines(input) \n",
    "display(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can save your figures with the `save()` function. The first argument is the name of the file you want to create. The second argument is the figure itself. The ending of the file name (`.png, .svg or .pdf`) determines the type of the output file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = range(start = 0,stop = 2π, length = 1000)\n",
    "# hint: to write π in Julia type \\pi and press tab\n",
    "y = sin.(x)\n",
    "f2 = lines(x,y)\n",
    "save(\"f2.png\", f2)\n",
    "save(\"f2.pdf\", f2)\n",
    "save(\"f2.svg\", f2)\n",
    "f2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you have created and saved your first plot. But a plot without title and labeled axes is more or less useless. To give a plot a title and labels you will have to dig a little deeper into the inner workings of Makie.\n",
    "So far you have used the `line()` function. This function does a lot of stuff for you automatically (creating a figure-, axis- and a plot- object). This is very convenient when ploting something quick and dirty. But to use `Makie` to its full potential, it is better to do some of the stuff manually. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. How to properly create Figures\n",
    "\n",
    "At first, you have to create a figure object with the `Figure()` function. A figure is the top object in Makie, it serves as the input argument to the top level functions `display` and `save` that you have already used. It has one keyword argument worth mentioning : `resolution` which defines its size. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f3 = Figure()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create figure f4 with a fixed resolution\n",
    "f4 = Figure(resolution = (800,400))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Adding axes to a Figure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As seen in the cells above, the created figures do not contain anything. Therefore, we have to create a set of x and y-axes in the figures with the `Axis()` function.\n",
    "\n",
    "Note: The nomenclature can become a bit confusing, as the `Axis()` functions always creates a set of x and y axes and not only one axis in the mathematical sense. But to follow the naming convention of `Makie`, a created set of axes will be called an axis in the following.  \n",
    "\n",
    "__Important: One figure can have multiple axes but every axis is only part of one figure.__\n",
    "\n",
    "The `Axis()` function needs the figure in which it should be created and its relative position inside the figure, as a positional argument. The first axis in every figure should always be created on the first y- and x-position: `figurename[1,1]`.  If you want mutiple axes in one figure, you can add more axes in either the y or x direction with  `figurename[y,x]`. Makie will scale the axes automatically to even sizes.\n",
    "\n",
    "The keyword argument `title` can be used to assign an axis a title. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax3_1 = Axis(f3[1,1],title = \"ax3_1\")\n",
    "display(f3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax4_1 = Axis(f4[1,1],title = \"ax4_1\")\n",
    "#add another axis to figure f4\n",
    "ax4_2 = Axis(f4[1,2],title = \"ax4_2\")\n",
    "display(f4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cells above,  one axis was created in f3 and two axes were created in f4. All these axes have been asigned a name to access them easier in the future. There are a lot more [keyword arguments](https://docs.makie.org/stable/examples/blocks/axis/) that can be used to modify an axis. This can be done during creation in the `Axis()`  function or  later by using the `axis.keyword_argument = ` syntax. Some of the important ones are:   `xlabel, ylabel, title, xlabelsize, ylabelsize, titlesize, backgroundcolor`. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax3_1.xlabel = \"time [s]\" \n",
    "ax3_1.xlabelsize = 40\n",
    "ax3_1.titlesize = 50\n",
    "f3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Warning__: \n",
    "\n",
    "If you have executed the cells above more than once, you might run into strange behaviour, as `Makie` does not automatically delete old axes when creating new ones with the same name. Old axes might still exist but do not have a name assigned to them anymore (very bad! ).  \n",
    "You can avoid that, by either always creating figures and axes together in one cell or by deleting old axes before creating new axes with the `delete!(axis)`  function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "delete!(ax4_1)\n",
    "ax4_1_1 = Axis(f4[1,1],title = \"ax4_1_1\", titlesize = 30, backgroundcolor = \"black\",ylabel = \"darkness\",xlabel =\"darkness\")\n",
    "f4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Ploting into an axis "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can finally start to plot into your created axes. You can use one of the many [plotting functions](https://docs.makie.org/stable/examples/plotting_functions/) that are provided by `Makie`. Some of the most important ones are `lines!(), scatter!(), hist!(), heatmap!()`. These functions create a plot into a given axis, if the axis is omitted then the last used axis is the default value.  If you want to modify a plot later on,  it makes sense to assign it to a variable as well (but you don't need to). \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comment: Makie also follows the Julia convention to end function names of mutation functions with `!` . While the `lines()` function created a new figure, axis and plot object, the function `lines!()` modifies an already existing axis, by adding a plot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatty =  scatter!(ax3_1, 10*rand(40),10*rand(40))\n",
    "liney = lines!(ax4_1_1,x,y)\n",
    "heaty = heatmap!(ax4_2, rand(10,10))\n",
    "display(f3)\n",
    "display(f4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to axes: Old plots are not deleted if a new one is created in its place and name. They still exist but do not have a name assigned to them anymore (very bad! ).  \n",
    "To avoid such problems, either create figure, axes and plots together or delete old plots with `delete!(axis, plot)` and old axes with `delete(axis)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "delete!(ax3_1,scatty)\n",
    "f3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The different plot functions `(lines!(), scatter!(),...)` also have a lot of keyword arguments like `label, linewith, marker, markersize, color ... `.  Similar to axes, these keyword arguments can be provided during creation or later with the `plot_name.keywordargument = ` syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#adding keyword arguments during creation\n",
    "scatty2 =  scatter!(ax3_1, 10*rand(40),10*rand(40),marker = '✈', color = :red,markersize = 20)\n",
    "#f3\n",
    "f3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding keyword arguments after creation \n",
    "liney.linewidth = 10\n",
    "liney.linestyle = :dash\n",
    "display(f4) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Making a legend "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Automatically created legends in `Makie` are always linked to an axis. Every plot inside said axis that has been assined a  `label`, will appear inside the legend. \n",
    "\n",
    "There are two different ways to place a legend. You can either create a legend outside of an axis with the `Legend()` function. \n",
    "The arguments of this function are: First, the relative position inside the figure and second, the axis to which the legend is refering. A third optional argument is a string, which will be used as the title of the legend.  \n",
    "\n",
    "If you want to create a legend inside an axis, you can use the `axislegend` function. In this case, you only have to supply the axis to which the legend refers.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the previously created plots, didn't included a label, you need to add it with the `plot_name.label = \"name\"` synatx. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatty2.label = \"Airplanes\"\n",
    "leggy = Legend(f3[1,2],ax3_1,\"Title\")\n",
    "f3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to add the label during the creation of a plot with the keyword argument `label = \"plotname\"`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liney.label = \"sinus\"\n",
    "liney_squared_n = lines!(ax4_1_1,x,-y.^2, label = \"-sinus²\")\n",
    "axislegend(ax4_1_1)\n",
    "f4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the legends shown so far, used the `labels` of the plots. It is also possible to manually write text into a legend or only use every second plot, etc. ... Everything regarding legends can be found [here](https://docs.makie.org/stable/examples/blocks/legend/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important keyword argument of many plotting function is `color` keyword argument.\n",
    "\n",
    "If you change the color of a plot, an automatically created legend gets updated as well :). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liney.color = \"green\"\n",
    "f4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: All available colors can be found [here](http://juliagraphics.github.io/Colors.jl/stable/namedcolors/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Everything comes together "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below you can see the step by step creation of a figure with two plots, one axis and a legend.  This is the way you should create your plots from now on:  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1 Line Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1,y1 = [1,2,3,4],[5,7,10,16]./19\n",
    "x2,y2 = [1,2,3,4],[12,7,5,2]./19\n",
    "\n",
    "f5 = Figure()\n",
    "ax5_1 = Axis(f5[1,1],title = \"Covid Variants\", titlesize = 25, backgroundcolor = \"salmon1\",\n",
    "    ylabel = \"occurence [%]\",xlabel =\"time [months]\",\n",
    "    xlabelsize = 20, ylabelsize = 20) \n",
    "line5_1_1 = lines!(ax5_1, x1 ,y1, label = \"Omikron\", linestyle  = :dash, color = \"darkgreen\",linewidth = 5)\n",
    "line5_1_2 = lines!(ax5_1, x2, y2, label = \"Delta\", linestyle  = :dashdot, color = \"royalblue3\",linewidth = 5)\n",
    "axislegend(ax5_1,position = :rc)  # positon is keyworded by two things r or l (right or left) and t,c,b (top, center, bottom) \n",
    "#setting ylimit after creating plot \n",
    "ylims!(ax5_1,0,1.0)\n",
    "f5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2 Bar Plot\n",
    "Bar plots are one of the most common types of graphs, which allow you to show data associated with categorical variables. In Makie `barplot!()` is the function for this purpose. This function takes the arguments: `(axis, x, y)`. Supported [keyword arguments](https://docs.makie.org/stable/examples/plotting_functions/barplot/) include `color, strokecolor , strokewidth`,... . To customize the x-axis for categories instead of coordinates, you can use the keyword argument `xticks(x, categories)`, which maps coordinates to an equally long sequences of categories. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "category=[\"A\", \"B\", \"C\", \"D\"]\n",
    "x_range = 1:length(category)\n",
    "values=[44,55,32,41]\n",
    "\n",
    "f6 = Figure()\n",
    "ax6_1 = Axis(f6[1, 1], xticks = (x_range, category), title = \"Bar Plot\")\n",
    "bari6_1 = barplot!(ax6_1, x_range,values, strokecolor = :black, strokewidth = 2)\n",
    "\n",
    "f6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.3 Colors\n",
    "Makie automatically assigns a new color to a new plot. In many cases, this can be sufficient to colorise  a plot. Like here, where four different barplots are created in one axis.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "category=[\"A\", \"B\", \"C\", \"D\"]\n",
    "x_range = 1:length(category)\n",
    "values=[44.0,55,32,41]\n",
    "\n",
    "f7 = Figure()\n",
    "ax7_1 = Axis(f7[1, 1], xticks = (x_range, category), title = \"Bar Plot\")\n",
    "for i in x_range\n",
    "    barplot!(ax7_1, [i],[values[i]], strokecolor = :black, strokewidth = 2) \n",
    "    # Hint:  you have to write [i] and [values[i]] instead of i and values[i] as makie can only work with arrays or iterabales as input not with numbers\n",
    "end\n",
    "f7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to change the color of each bar/scatter/vector/line segment in a single plot separately. In this case, you need to provide a vector of colors to the keyword argument `color` with the same length as your datapoints.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "category=[\"A\", \"B\", \"C\", \"D\"]\n",
    "x_range = 1:length(category)\n",
    "values=[44,55,32,41]\n",
    "color_vec = [\"red\",\"yellow\",\"green\",\"blue\"]\n",
    "\n",
    "f8 = Figure()\n",
    "ax8_1 = Axis(f8[1, 1], xticks = (x_range, category), title = \"Bar Plot\")\n",
    "bari8_1 = barplot!(ax8_1, x_range,values, strokecolor = :black, strokewidth = 2,color = color_vec)\n",
    "\n",
    "f8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For many data points, this can become quite annoying. Therefore, you can also use predefined vectors of colors from the package `ColorSchemes`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ColorSchemes as co"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can access the vast catalog of possible [colorvectors](https://juliagraphics.github.io/ColorSchemes.jl/stable/catalogue/).\n",
    "\n",
    "Just some examples below: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "co.glasbey_hv_n256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "co.ocean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "co.prism"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can provide a slice of every predefined colorvectors to the `color` keyword argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "category=[\"A\", \"B\", \"C\", \"D\"]\n",
    "x_range = 1:length(category)\n",
    "values=[44,55,32,41]\n",
    "\n",
    "#slicing the color vector to the range we need in our plot: \n",
    "\n",
    "#color_vec = co.prism[x_range]\n",
    "color_vec = co.glasbey_hv_n256[x_range]\n",
    "\n",
    "f9 = Figure()\n",
    "ax9_1 = Axis(f9[1, 1], xticks = (x_range, category), title = \"Bar Plot\")\n",
    "bari9_1 = barplot!(ax9_1, x_range,values, strokecolor = :black, strokewidth = 2,color = color_vec)\n",
    "\n",
    "f9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Note: Everything you have learned here regarding colors is true for every type of plot in Makie (not only barplots).__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4 Errorbars\n",
    "Makie has its own `errorbars!()` ploting function, which can be used on top of every type of plot. Its positional arguments are `x, y, and error`. It also has some [keyword arguments](https://docs.makie.org/stable/examples/plotting_functions/errorbars/) like `whiskerwidth`, which defines the size of the horizontal line on top and `direction` which is `:y` per default,  but can be changed to `:x` to plot errors in the x-direction. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "category=[\"A\", \"B\", \"C\", \"D\"]\n",
    "x_range = 1:length(category)\n",
    "values=[44,55,32,41]\n",
    "\n",
    "#color_vec = co.prism[x_range]\n",
    "color_vec = co.glasbey_hv_n256[x_range]\n",
    "\n",
    "f10 = Figure()\n",
    "ax10_1 = Axis(f10[1, 1], xticks = (x_range, category), title = \"Bar Plot\")\n",
    "bari10_1 = barplot!(ax10_1, x_range,values, strokecolor = :black, strokewidth = 2,color = color_vec)\n",
    "\n",
    "# adding error and erro bar plot\n",
    "error=[5,8,7,9]\n",
    "\n",
    "erri6_1 = errorbars!(ax10_1, x_range,values, error,whiskerwidth = 20)\n",
    "f10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.5 Histograms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Histograms are a very common type of plot for the frequency distribution of continuous data. In `Makie`, histograms are created with the function `hist!()`, which takes an array of values as input argument. The most important keyword argument is `bins` which is the number of bins to be drawn. Further optional arguments are `normalization = :pdf`, which rescales the data to a probability density function and all probabilties sum up to 1. Many more keyword arguments like  `Color`, `strokewidth` , `strokecolor` can be found [here](https://docs.makie.org/stable/examples/plotting_functions/hist/).  \n",
    "\n",
    "To create some artifical data for plotting, the package `Distributions` is used.  Together with the `rand()` function, it is possible to sample values from a huge number of [probability distributions](https://juliastats.org/Distributions.jl/stable/univariate/#Continuous-Distributions). In this case, 10,000 data points are sampled from a Normal distribution `Normal(0,2)` with `mean = 0` and `standard deviation = 2`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist_data = rand(Normal(0,2),10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f11 = Figure()\n",
    "ax11_1 = Axis(f11[1, 1], title = \"My first Histogram in Julia :)\")\n",
    "histi11_1 = hist!(ax11_1, dist_data, )\n",
    "f11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can make the plot look nicer with all the tools you have learned so far. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f12 = Figure()\n",
    "ax12_1 = Axis(f12[1, 1], title = \"My second Histogram in Julia :)\",xlabel = \"data\",ylabel = \"count\")\n",
    "histi12_1 = hist!(ax12_1, dist_data, bins = 50,strokewidth = 1, strokecolor = :black )\n",
    "f12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f13 = Figure()\n",
    "ax13_1 = Axis(f13[1, 1], title = \"My third Histogram in Julia :)\",xlabel = \"data\",ylabel = \"probabilty\")\n",
    "histi13_1 = hist!(ax13_1, dist_data, bins = 50,strokewidth = 1, strokecolor = :black, normalization = :pdf, color =co.nipy_spectral[1:50] )\n",
    "f13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Box-Whisker Plot\n",
    "Like a histogram, a box-whisker plot is a way to graphically show the distribution of values. In `Makie`, the function `boxplot!()` leads to a box-whisker plot. `boxplot()` needs the input data in form of two arrays. One array with the position of the marks on the x-axis for every data point, and one containing the value of every datapoint. Optional keyword arguments can costumize the plot. For example, you can make a horizontal box plot with `orientation:horizontal`. More keyword arguments can be found [here](https://makie.juliaplots.org/stable/examples/plotting_functions/boxplot/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_points = 1000\n",
    "\n",
    "y1 = rand(Normal(),data_points)\n",
    "y2 = rand(Beta(),data_points)\n",
    "y3 = rand(Erlang() ,data_points)\n",
    "xs = [1 for i in 1:data_points]\n",
    "\n",
    "\n",
    "xs = append!(xs,xs.*2,xs.*3)\n",
    "ys = append!(y1,y2,y3)\n",
    "\n",
    "boxplot(xs,ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Short  Summary\n",
    "\n",
    "- The package `Makie` can be used to create scientifc visualizations in Julia \n",
    "- Its backend `CairoMakie` is best suited for publication qualtiy static plots\n",
    "- Each visualization consists out of a figure object which can contain multiples axes which can contain multiple plots\n",
    "- Use keyword arguments in the `Axis()` and plotting functions to customize a plot "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "\n",
    "All exercises in this course are divided into three different difficulty categories: <span style=\"color:green\">easy</span>, <span style=\"color:orange\">medium</span> and <span style=\"color:red\">hard</span>. <span style=\"color:green\">Easy</span> exercises should be solvable solely with the contents of the respective notebook. <span style=\"color:orange\">Medium</span> often require the transfer of known concepts to new problems. Therefore, it might be necessary to look up some old notebooks or to use your creativity and curiosity to combine seemingly unrelated stuff. <span style=\"color:red\">Hard</span> exercises take this concept one step further and might require you to use additional resources like the official documentation, google, StackOverflow,... . "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <p style='color: green'>  Always make pretty plots (title, axis labeling, nice colors, legend, axis limits, grid (where appropriate), ...) !!!</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Execute the first cell to get some data that you can plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you will learn how this function works in the next chapter import/export\n",
    "# don't worry for now and just execute this cell \n",
    "\n",
    "function Julia_parser(path::String)\n",
    "    eval(Meta.parse(readline(path)))\n",
    "end\n",
    "\n",
    "averagetemp_Station3 = Julia_parser(\"Temperatur_Station3.json\")\n",
    "averagetemp_Station44 = Julia_parser(\"Temperatur_Station44.json\")\n",
    "averagetemp_Station73 = Julia_parser(\"Temperatur_Station73.json\")\n",
    "rainfall_Station3 = Julia_parser(\"Niederschlag_Station3.json\")\n",
    "rainfall_Station44 = Julia_parser(\"Niederschlag_Station44.json\")\n",
    "rainfall_Station73 = Julia_parser(\"Niederschlag_Station73.json\")\n",
    "\n",
    "\n",
    "\n",
    "Histolist = rand(Normal(100,15),100000)\n",
    "loglist=[exp(-i*0.1) for i in range(1,81)]\n",
    "Months=[\"Jan\",\"Feb\",\"Mar\",\"Apr\",\"May\",\"Jun\",\"Jul\",\"Aug\",\"Sep\",\"Oct\",\"Nov\",\"Dec\"];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### <p style='color: green'>easy</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Plot average temperatures per month at the three different stations against the months in three different figures as lines plots together with a legend."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Plot average temperatures per month at the three different stations against the months in three different scatter plots with different colors into the same figure but three different axes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Make a bar plot of the rainfall per month at station 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Make a boxplot of the temperatures at each station."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <p style='color: orange'>medium</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Make a histogramm of `Histolist`, which contains generated data of an IQ distribution, with `100` bins. \n",
    "\n",
    "    Add a black vertical line at `100`. \n",
    "\n",
    "    Hint: There is a very useful predefined function for vertical lines in makie. Check the [documentation]( https://docs.makie.org/stable/examples/plotting_functions/) to save a lot of work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Use the Makie documentation to study the additional keyword arguments for `hist()`. Use this to make  a histogram using the same data as in 5., but plot the probabilty density instead of the frequency of the IQ , `20` bins, a nice looking stroke and change one additonal feature of your choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Look at the offical documentation of [themes](https://docs.makie.org/stable/documentation/theming/) in Makie. Choose one of the [predefined themes](https://docs.makie.org/stable/documentation/theming/predefined_themes/) and activate it with the function `set_theme!()`. Recreate some of the plots in the previous exercises. \n",
    "Use the function `update_theme!()` to change one or more settings of the theme to customize it for your needs. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Make a plot of `loglist`, which could resemble the decline of something over time (just come up with something for your labels), without and with a logarithmic y-axis (use the documentation)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <p style='color: red'>hard</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. Make a diagram in wich `averagetemp_Station73` is plotted as a line graph and `rainfall_Station73` is plotted as a bar graph. Try to get the axis for rainfall on the right and for temperature on the left side of the diagram. Check the [documentation](https://docs.makie.org/stable/examples/blocks/axis/#creating_a_twin_axis) of twin axis to find out how.     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. Make a plot with the rainfall of all three stations in one bar graph where the three different bars are shown for every month and without grid. Check the [documentation](https://docs.makie.org/stable/examples/plotting_functions/barplot/) of barplot, to find out how.     "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.9.2",
   "language": "julia",
   "name": "julia-1.9"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}