some cleanups

Author: Mohammed Sadique

lib/matplotex/figure/areal.ex

@@ -1,4 +1,5 @@
 defmodule Matplotex.Figure.Areal do
+  alias Matplotex.Figure.Areal.Ticker
   alias Matplotex.Utils.Algebra
   alias Matplotex.Figure.Dataset
   alias Matplotex.Figure.TwoD
@@ -79,8 +80,13 @@ defmodule Matplotex.Figure.Areal do
         |> update_tick(tick)
       end
 
-      def add_ticks(%__MODULE__{tick: tick, size: size} = axes, {key, {_min, _max} = lim}) do
-        {ticks, lim} = __MODULE__.generate_ticks(lim)
+      def add_ticks(%__MODULE__{tick: tick, size: {width, height}= size} = axes, {key, {_min, _max} = lim}) do
+        number_of_ticks = if key == :x do
+          ceil(width)
+        else
+          ceil(height)
+        end
+        {ticks, lim} = Ticker.generate_ticks(lim, number_of_ticks )
 
         tick = Map.put(tick, key, ticks)
 
@@ -116,23 +122,6 @@ defmodule Matplotex.Figure.Areal do
         %{axes | legend: legend}
       end
 
-      def generate_xticks(%module{data: {x, _y}, tick: tick, limit: limit} = axes) do
-        {xticks, xlim} =
-          module.generate_ticks(x)
-
-        tick = Map.put(tick, :x, xticks)
-        limit = update_limit(limit, :x, xlim)
-        %__MODULE__{axes | tick: tick, limit: limit}
-      end
-
-      def generate_yticks(%module{data: {_x, y}, tick: tick, limit: limit} = axes) do
-        {yticks, ylim} =
-          module.generate_ticks(y)
-
-        tick = Map.put(tick, :y, yticks)
-        limit = update_limit(limit, :y, ylim)
-        %__MODULE__{axes | tick: tick, limit: limit}
-      end
 
       defp update_limit(%TwoD{x: nil} = limit, :x, xlim) do
         %TwoD{limit | x: xlim}

lib/matplotex/figure/areal/bar_chart.ex

@@ -91,16 +91,6 @@ defmodule Matplotex.Figure.Areal.BarChart do
     %Figure{figure | axes: %{axes | element: elements_with_bar}}
   end
 
-  def plotify(value, {minl, maxl}, axis_size, transition, _data, :x) do
-    s = axis_size / (maxl - minl)
-    value * s + transition - minl * s
-  end
-
-  def plotify(value, {minl, maxl}, axis_size, transition, _data, :y) do
-    s = axis_size / (maxl - minl)
-    value * s + transition - minl * s
-  end
-
   @impl Areal
   def with_legend_handle(
         %Legend{x: x, y: y, color: color, width: width, height: height} = legend,

lib/matplotex/figure/areal/histogram.ex

@@ -8,10 +8,13 @@ defmodule Matplotex.Figure.Areal.Histogram do
   alias Matplotex.Figure.Areal
   use Areal
 
+  @make_it_zero 0
+
   frame(
     tick: %TwoD{},
     limit: %TwoD{},
     label: %TwoD{},
+    scale: %TwoD{},
     region_x: %Region{},
     region_y: %Region{},
     region_title: %Region{},
@@ -20,12 +23,11 @@ defmodule Matplotex.Figure.Areal.Histogram do
   )
 
   @impl Areal
-  def create(%Figure{axes: %__MODULE__{} = axes} = figure, {data, bins}, opts) do
+  def create(%Figure{axes: %__MODULE__{} = axes, rc_params: rc_params} = figure, {data, bins}, opts) do
     {x, y} = bins_and_hists(data, bins)
 
     dataset = Dataset.cast(%Dataset{x: x, y: y}, opts)
-
-    %Figure{figure | axes: %__MODULE__{axes | data: {x, y}, dataset: [dataset]}}
+    %Figure{figure | axes: %__MODULE__{axes | data: {x, y}, dataset: [dataset]}, rc_params: %RcParams{rc_params | y_padding: @make_it_zero}}
     |> PlotOptions.set_options_in_figure(opts)
   end
 
@@ -119,8 +121,7 @@ defmodule Matplotex.Figure.Areal.Histogram do
   defp sanitize(%Figure{axes: %__MODULE__{data: {x, y}}= axes} = figure) do
     {ymin, ymax} = Enum.min_max(y)
     {xmin, xmax} = Enum.min_max(x)
-    {xmin, xmax} = {floor(xmin), ceil(xmax)}
 
-    %Figure{figure | axes: %__MODULE__{axes | limit: %TwoD{y: {floor(ymin), ceil(ymax)}, x: xlim }}}
+    %Figure{figure | axes: %__MODULE__{axes | limit: %TwoD{x: {floor(xmin), ceil(xmax)},y: {floor(ymin), ceil(ymax)}}}}
    end
 end

lib/matplotex/figure/areal/line_plot.ex

@@ -93,12 +93,6 @@ defmodule Matplotex.Figure.Areal.LinePlot do
     %Figure{figure | axes: %{axes | element: elements}}
   end
 
-  @impl Areal
-  def plotify(value, {minl, maxl}, axis_size, transition, _, _) do
-    s = axis_size / (maxl - minl)
-    value * s + transition - minl * s
-  end
-
   @impl Areal
   def with_legend_handle(
         %Legend{x: x, y: y, color: color, width: marker_size} = legend,

lib/matplotex/figure/areal/scatter.ex

@@ -132,11 +132,6 @@ defmodule Matplotex.Figure.Areal.Scatter do
   end
 
   defp capture(_, captured, _), do: captured
-  @impl Areal
-  def plotify(value, {minl, maxl}, axis_size, transition, _, _) do
-    s = axis_size / (maxl - minl)
-    value * s + transition - minl * s
-  end
 
   @impl Areal
   def with_legend_handle(

lib/matplotex/figure/areal/ticker.ex

@@ -4,6 +4,9 @@ defmodule Matplotex.Figure.Areal.Ticker do
     step = (max - min) / @tick_in_plot
     produce_ticks(min, max, step, [format_number(min)])
   end
+  def generate_ticks({lower_limit, upper_limit} = lim, number_of_ticks) do
+    {lower_limit |> Nx.linspace(upper_limit, n: number_of_ticks) |> Nx.to_list(), lim}
+  end
 
   defp produce_ticks(value, max, _step, ticks) when value >= max do
     Enum.reverse(ticks)

lib/matplotex/figure/cast.ex

@@ -12,7 +12,6 @@ defmodule Matplotex.Figure.Cast do
   alias Matplotex.Figure.Coords
   alias Matplotex.Figure
   alias Matplotex.Figure.Dataset
-  @tickline_offset 5 / 96
   @xtick_type "figure.x_tick"
   @ytick_type "figure.y_tick"
   @stroke_grid "#ddd"
@@ -326,85 +325,6 @@ defmodule Matplotex.Figure.Cast do
     %Figure{figure | axes: %{axes | element: element}}
   end
 
-  def cast_xticks(
-        %Figure{
-          axes:
-            %module{
-              tick: %{x: x_ticks},
-              limit: %{x: {_min, _max} = xlim},
-              size: {width, _height},
-              data: {x_data, y_data},
-              dataset: dataset,
-              element: elements,
-              show_x_ticks: true,
-              coords: %Coords{bottom_left: {blx, bly}, x_ticks: {_xtx, xty}} = coords
-            } = axes,
-          rc_params: %RcParams{x_tick_font: tick_font, x_padding: x_padding}
-        } = figure
-      )
-      when is_list(x_ticks) do
-    # TODO: Only if it has to confine
-    x_ticks = confine_ticks(x_ticks, xlim)
-    x_data = confine_data(x_data, xlim)
-    dataset = confine_data(dataset, xlim, :x)
-
-    {xtick_elements, vgridxs} =
-      Enum.map(x_ticks, fn tick ->
-        {tick_position, label} =
-          plotify_tick(
-            module,
-            tick,
-            xlim,
-            width - width * x_padding * 2,
-            blx + width * x_padding,
-            x_data,
-            :x
-          )
-
-        label =
-          %Label{
-            type: @xtick_type,
-            x: tick_position,
-            y: xty,
-            text: label
-          }
-          |> merge_structs(tick_font)
-
-        # TODO: find a mechanism to pass custom font for ticks
-        line = %Line{
-          type: @xtick_type,
-          x1: tick_position,
-          y1: bly,
-          x2: tick_position,
-          y2: bly - @tickline_offset
-        }
-
-        {%Tick{type: @xtick_type, tick_line: line, label: label}, tick_position}
-      end)
-      |> Enum.unzip()
-
-    elements = elements ++ xtick_elements
-    vgrids = Enum.map(vgridxs, fn g -> {g, bly} end)
-
-    %Figure{
-      figure
-      | axes: %{
-          axes
-          | data: {x_data, y_data},
-            dataset: dataset,
-            element: elements,
-            coords: %{coords | vgrids: vgrids}
-        }
-    }
-  end
-
-  def cast_xticks(%Figure{axes: %{tick: %{x: _}, limit: %{x: nil}, show_x_ticks: true}} = figure) do
-    figure
-    |> set_xlim_from_ticks()
-    |> cast_xticks()
-  end
-
-  def cast_xticks(%Figure{} = figure), do: figure
 
   def cast_xticks_by_region(
         %Figure{
@@ -507,86 +427,6 @@ defmodule Matplotex.Figure.Cast do
     @lowest_tick |> Nx.linspace(axis_size, n: number_of_ticks_required) |> Nx.to_list()
   end
 
-  @spec cast_yticks(Matplotex.Figure.t()) :: Matplotex.Figure.t()
-  def cast_yticks(
-        %Figure{
-          axes:
-            %module{
-              tick: %{y: y_ticks},
-              size: {_width, height},
-              element: elements,
-              coords: %Coords{bottom_left: {blx, bly}, y_ticks: {ytx, _yty}} = coords,
-              limit: %{y: {_min, _max} = ylim},
-              data: {x_data, y_data},
-              dataset: dataset,
-              show_y_ticks: true
-            } = axes,
-          rc_params: %RcParams{y_tick_font: tick_font, y_padding: padding}
-        } = figure
-      ) do
-    y_ticks = confine_ticks(y_ticks, ylim)
-    y_data = confine_data(y_data, ylim)
-    dataset = confine_data(dataset, ylim, :y)
-
-    {ytick_elements, hgridys} =
-      Enum.map(y_ticks, fn tick ->
-        {tick_position, label} =
-          plotify_tick(
-            module,
-            tick,
-            ylim,
-            height - height * padding * 2,
-            bly + height * padding,
-            y_data,
-            :y
-          )
-
-        label =
-          %Label{
-            type: @ytick_type,
-            y: tick_position,
-            x: ytx,
-            text: label,
-            text_anchor: "end",
-            dominant_baseline: "middle"
-          }
-          |> merge_structs(tick_font)
-
-        # TODO: find a mechanism to pass custom font for ticks
-        line = %Line{
-          type: @ytick_type,
-          y1: tick_position,
-          x1: blx,
-          x2: blx - @tickline_offset,
-          y2: tick_position
-        }
-
-        {%Tick{type: @ytick_type, tick_line: line, label: label}, tick_position}
-      end)
-      |> Enum.unzip()
-
-    elements = elements ++ ytick_elements
-    hgrids = Enum.map(hgridys, fn g -> {blx, g} end)
-
-    %Figure{
-      figure
-      | axes: %{
-          axes
-          | data: {x_data, y_data},
-            dataset: dataset,
-            element: elements,
-            coords: %{coords | hgrids: hgrids}
-        }
-    }
-  end
-
-  def cast_yticks(%Figure{axes: %{tick: %{y: _}, limit: %{y: nil}, show_y_ticks: true}} = figure) do
-    figure
-    |> set_ylim_from_ticks()
-    |> cast_yticks()
-  end
-
-  def cast_ytick(%Figure{} = figure), do: figure
 
   def cast_yticks_by_region(
         %Figure{
@@ -853,23 +693,6 @@ defmodule Matplotex.Figure.Cast do
 
   def cast_legends(figure), do: figure
 
-  defp plotify_tick(module, {label, value}, lim, axis_size, transition, data, axis) do
-    {module.plotify(value, lim, axis_size, transition, data, axis), label}
-  end
-
-  defp plotify_tick(module, value, lim, axis_size, transition, data, axis) do
-    {module.plotify(value, lim, axis_size, transition, data, axis), value}
-  end
-
-  defp min_max([{_pos, _label} | _] = ticks) do
-    ticks
-    |> Enum.min_max_by(fn {_labe, pos} -> pos end)
-    |> then(fn {{_label_min, pos_min}, {_label_max, pos_max}} -> {pos_min, pos_max} end)
-  end
-
-  defp min_max(ticks) do
-    Enum.min_max(ticks)
-  end
 
   defp calculate_center(%Coords{bottom_left: bottom_left, bottom_right: bottom_right}, {x, y}, :x) do
     {calculate_distance(bottom_left, bottom_right) / 2 + x, y}
@@ -899,24 +722,6 @@ defmodule Matplotex.Figure.Cast do
 
   defp rotate_label(:y), do: -90
 
-  defp set_xlim_from_ticks(%Figure{axes: %module{tick: %{x: xtick}} = axes} = figure) do
-    {xmin, xmax} = min_max(xtick)
-
-    xscale = xmax |> round() |> div(length(xtick) - 1)
-
-    xlim = {round(xmin - xscale), round(xmax + xscale)}
-    axes = module.set_limit(axes, {:x, xlim})
-
-    %Figure{figure | axes: axes}
-  end
-
-  defp set_ylim_from_ticks(%Figure{axes: %module{tick: %{y: ytick}} = axes} = figure) do
-    {ymin, ymax} = min_max(ytick)
-    yscale = ymax |> round() |> div(length(ytick) - 1)
-    ylim = {round(ymin - yscale), round(ymax + yscale)}
-    axes = module.set_limit(axes, {:y, ylim})
-    %Figure{figure | axes: axes}
-  end
 
   defp confine_ticks([{_l, _v} | _] = ticks, {min, max}) do
     ticks

lib/matplotex/figure/lead.ex

@@ -56,6 +56,7 @@ defmodule Matplotex.Figure.Lead do
   defp ensure_ticks_are_valid(
          %Figure{
            figsize: {width, height},
+           rc_params: %RcParams{x_ticks_count: x_ticks_count, y_ticks_count: y_ticks_count},
            axes:
              %{
                data: {x_data, y_data},
@@ -64,8 +65,8 @@ defmodule Matplotex.Figure.Lead do
              } = axes
          } = figure
        ) do
-    {x_ticks, x_lim} = maybe_generate_ticks(x_ticks, x_lim, x_data, width)
-    {y_ticks, y_lim} = maybe_generate_ticks(y_ticks, y_lim, y_data, height)
+    {x_ticks, x_lim} = maybe_generate_ticks(x_ticks, x_lim, x_data, x_ticks_count || width)
+    {y_ticks, y_lim} = maybe_generate_ticks(y_ticks, y_lim, y_data, y_ticks_count || height)
 
     %Figure{
       figure

lib/matplotex/figure/rc_params.ex

@@ -48,7 +48,9 @@ defmodule Matplotex.Figure.RcParams do
             white_space: 0,
             label_padding: @label_padding,
             legend_width: @default_legend_width_percentage,
-            legend_items_orientation: @default_legend_items_orientation
+            legend_items_orientation: @default_legend_items_orientation,
+            x_ticks_count: nil,
+            y_ticks_count: nil
 
   def get_rc(%__MODULE__{} = rc_param, get_func) do
     apply(__MODULE__, get_func, [rc_param])