fixes

Author: Mohammed Sadique

lib/matplotex/figure/areal.ex

@@ -141,6 +141,7 @@ defmodule Matplotex.Figure.Areal do
       def materialized_by_region(figure) do
         figure
         |> Lead.set_regions_areal()
+        |> Lead.transform_sizes()
         |> Cast.cast_xticks_by_region()
         |> Cast.cast_yticks_by_region()
         |> Cast.cast_hgrids_by_region()
@@ -184,6 +185,7 @@ defmodule Matplotex.Figure.Areal do
 
         {x, y}
       end
+
       def flatten_for_data(_, _bottom) do
         raise InputError, bottom: "Wrong data provided for opts bottom"
       end
@@ -439,18 +441,28 @@ defmodule Matplotex.Figure.Areal do
     %Dataset{dataset | transformed: transformed}
   end
 
-  defp maybe_wrap_with_sizes(transformed, %Dataset{sizes: sizes} = dataset) when length(transformed) == length(sizes) do
-   {Enum.zip(transformed,sizes), dataset}
+  defp maybe_wrap_with_sizes(transformed, %Dataset{sizes: sizes} = dataset)
+       when length(transformed) == length(sizes) do
+    {Enum.zip(transformed, sizes), dataset}
   end
-  defp maybe_wrap_with_sizes(transformed, %Dataset{colors: colors, marker_size: marker_size} = dataset) when length(transformed) == length(colors) do
-    {Enum.zip(transformed,List.duplicate(marker_size,length(transformed))),dataset }
+
+  defp maybe_wrap_with_sizes(
+         transformed,
+         %Dataset{colors: colors, marker_size: marker_size} = dataset
+       )
+       when length(transformed) == length(colors) do
+    {Enum.zip(transformed, List.duplicate(marker_size, length(transformed))), dataset}
   end
+
   defp maybe_wrap_with_sizes(transformed, dataset) do
     {transformed, dataset}
   end
-  defp maybe_wrap_with_colors({transformed, %Dataset{colors: colors}}) when length(transformed) == length(colors) do
+
+  defp maybe_wrap_with_colors({transformed, %Dataset{colors: colors}})
+       when length(transformed) == length(colors) do
     Enum.zip(transformed, colors)
   end
+
   defp maybe_wrap_with_colors({transformed, _dataset}), do: transformed
 
   defp transform_with_bottom(x, y, xlim, ylim, width, height, transition) when is_list(y) do

lib/matplotex/figure/areal/scatter.ex

@@ -32,7 +32,7 @@ defmodule Matplotex.Figure.Areal.Scatter do
   def create(%Figure{axes: %__MODULE__{dataset: data} = axes} = figure, {x, y}, opts \\ []) do
     x = determine_numeric_value(x)
     y = determine_numeric_value(y)
-    dataset = Dataset.cast(%Dataset{x: x, y: y}, opts)|> Dataset.update_cmap()
+    dataset = Dataset.cast(%Dataset{x: x, y: y}, opts) |> Dataset.update_cmap()
     datasets = data ++ [dataset]
     xydata = flatten_for_data(datasets)
 
@@ -89,19 +89,26 @@ defmodule Matplotex.Figure.Areal.Scatter do
     elements = elements ++ line_elements
     %Figure{figure | axes: %{axes | element: elements}}
   end
+
   def capture(%Dataset{transformed: transformed} = dataset, concurrency) do
     if concurrency do
       process_concurrently(transformed, concurrency, [[], dataset])
     else
       capture(transformed, [], dataset)
     end
   end
-  def capture([{{{x, y}, s},color}| to_capture],captured, %Dataset{
-    marker: marker,
-    colors: colors,
-    cmap: cmap
-  }= dataset) do
-    color = colors |> Enum.min_max()|>Garner.garn_color(color, cmap)
+
+  def capture(
+        [{{{x, y}, s}, color} | to_capture],
+        captured,
+        %Dataset{
+          marker: marker,
+          colors: colors,
+          cmap: cmap
+        } = dataset
+      ) do
+    color = colors |> Enum.min_max() |> Garner.garn_color(color, cmap)
+
     capture(
       to_capture,
       captured ++
@@ -111,10 +118,15 @@ defmodule Matplotex.Figure.Areal.Scatter do
       dataset
     )
   end
-  def capture([{{x, y}, s}| to_capture],captured, %Dataset{
-    color: color,
-    marker: marker,
-  }= dataset) do
+
+  def capture(
+        [{{x, y}, s} | to_capture],
+        captured,
+        %Dataset{
+          color: color,
+          marker: marker
+        } = dataset
+      ) do
     capture(
       to_capture,
       captured ++
@@ -144,7 +156,6 @@ defmodule Matplotex.Figure.Areal.Scatter do
     )
   end
 
-
   def capture(_, captured, _), do: captured
 
   @impl Areal

lib/matplotex/figure/dataset.ex

@@ -37,5 +37,4 @@ defmodule Matplotex.Figure.Dataset do
   def update_cmap(%__MODULE__{cmap: cmap} = dataset) do
     %__MODULE__{dataset | cmap: Colormap.fetch_cmap(cmap)}
   end
-
 end

lib/matplotex/figure/lead.ex

@@ -46,29 +46,45 @@ defmodule Matplotex.Figure.Lead do
     ty = fig_height - fig_height * margin
     %Figure{figure | axes: %{axes | border: {lx, by, rx, ty}}}
   end
+
   def transform_sizes(%Figure{axes: %{dataset: datasets} = axes} = figure) do
     datasets = transform_dataset_sizes(figure, datasets, [])
     %Figure{figure | axes: %{axes | dataset: datasets}}
   end
-  defp transform_dataset_sizes(%Figure{axes: %{region_content: %Region{width: width_region_content, height: height_region_content}}}=figure, [%Dataset{sizes: sizes} = dataset | to_transorm], transformed) do
+
+  defp transform_dataset_sizes(_figure, [%Dataset{sizes: nil}| _to_transorm] = datasets, _),do: datasets
+
+  defp transform_dataset_sizes(
+         %Figure{
+           axes: %{
+             region_content: %Region{width: width_region_content, height: height_region_content}
+           }
+         } = figure,
+         [%Dataset{sizes: sizes} = dataset | to_transorm],
+         transformed
+       ) when length(sizes) > 0 do
     content_area = width_region_content * height_region_content
     total_size = Enum.sum(sizes)
+
     area_size_ratio =
-    if total_size > 0 do
-      (content_area / total_size) * 0.7
-    else
-      raise InputError, message: "Invalid sizes for fractionizing area"
-    end
+      if total_size > 0 do
+        content_area / total_size * 2
+      else
+        raise InputError, message: "Invalid sizes for fractionizing area"
+      end
 
     sizes =
-    sizes
-    |> Nx.tensor()
-    |> Nx.multiply(area_size_ratio)
-    |> Nx.to_list()
+      sizes
+      |> Nx.tensor()
+      |> Nx.multiply(area_size_ratio)
+      |> Nx.to_list()
+
     transform_dataset_sizes(figure, to_transorm, [%Dataset{dataset | sizes: sizes} | transformed])
   end
-  defp transform_dataset_sizes(_, [], transformed), do: transformed
+  defp transform_dataset_sizes(_figure, [%Dataset{sizes: []}| _to_transorm] = datasets, _), do: datasets
+
 
+  defp transform_dataset_sizes(_, [], transformed), do: transformed
 
   defp set_frame_size(%Figure{margin: margin, figsize: {fwidth, fheight}, axes: axes} = figure) do
     frame_size = {fwidth - fwidth * 2 * margin, fheight - fheight * 2 * margin}

test/matplotex/figure/areal/scatter_test.exs

@@ -14,32 +14,50 @@ defmodule Matplotex.Figure.Areal.ScatterTest do
       assert %Figure{axes: %{data: {x, _y}, element: elements}} = Scatter.materialize(figure)
       assert Enum.count(elements, fn elem -> elem.type == "plot.marker" end) == length(x)
     end
+
     test "generates elements with various saizes if it passed a size attrbute" do
-      x = [1,2,3,4,5]
+      x = [1, 2, 3, 4, 5]
       y = [10, 20, 30, 40, 50]
       sizes = [1, 2, 3, 4, 5]
-      assert %Figure{axes: %{element: elements}} = x|>Matplotex.scatter(y, sizes: sizes)|>Figure.materialize()
-     [h | tail] =  elements|>Enum.filter(fn x -> x.type == "plot.marker" end)|>Enum.map(fn x ->
-        x.r
-      end)
-     refute Enum.all?(tail, fn x -> x == h end)
 
+      assert %Figure{axes: %{element: elements}} =
+               x |> Matplotex.scatter(y, sizes: sizes) |> Figure.materialize()
+
+      [h | tail] =
+        elements
+        |> Enum.filter(fn x -> x.type == "plot.marker" end)
+        |> Enum.map(fn x ->
+          x.r
+        end)
+
+      refute Enum.all?(tail, fn x -> x == h end)
     end
 
     test "generates elements with various saizes and colors if it passed a size and color attrbute" do
-      x = [1,2,3,4,5]
+      x = [1, 2, 3, 4, 5]
       y = [10, 20, 30, 40, 50]
       sizes = [1, 2, 3, 4, 5]
-      assert %Figure{axes: %{element: elements}} = x|>Matplotex.scatter(y, sizes: sizes, colors: sizes)|>Figure.materialize()
-     [h | tail] =  elements|>Enum.filter(fn x -> x.type == "plot.marker" end)|>Enum.map(fn x ->
-        x.r
-      end)
-
-     refute Enum.all?(tail, fn x -> x == h end)
-     [h | tail] =  elements|>Enum.filter(fn x -> x.type == "plot.marker" end)|>Enum.map(fn x ->
-      x.fill
-    end)
-    refute Enum.all?(tail, fn x -> x == h end)
+
+      assert %Figure{axes: %{element: elements}} =
+               x |> Matplotex.scatter(y, sizes: sizes, colors: sizes) |> Figure.materialize()
+
+      [h | tail] =
+        elements
+        |> Enum.filter(fn x -> x.type == "plot.marker" end)
+        |> Enum.map(fn x ->
+          x.r
+        end)
+
+      refute Enum.all?(tail, fn x -> x == h end)
+
+      [h | tail] =
+        elements
+        |> Enum.filter(fn x -> x.type == "plot.marker" end)
+        |> Enum.map(fn x ->
+          x.fill
+        end)
+
+      refute Enum.all?(tail, fn x -> x == h end)
     end
   end
 
@@ -53,56 +71,99 @@ defmodule Matplotex.Figure.Areal.ScatterTest do
       assert length(ticks) == 6
     end
   end
+
   describe "do_transform" do
     test "zips transformed values with sizes if the dataset contains sizes in eaqual size" do
-      x = [1,2,3,4,5]
+      x = [1, 2, 3, 4, 5]
       y = [10, 20, 30, 40, 50]
       sizes = [1, 2, 3, 4, 5]
       width = 2
       height = 2
-      assert %Figure{axes: %{dataset: [dataset]}} = x|>Matplotex.scatter(y,figsize: {width, height}, sizes: sizes)
-      assert %Dataset{transformed: transformed} = Areal.do_transform(dataset, Enum.min_max(x), Enum.min_max(y),width, height, {0,0})
-      assert Enum.all?(transformed, &match?({{_,_},_}, &1))
 
+      assert %Figure{axes: %{dataset: [dataset]}} =
+               x |> Matplotex.scatter(y, figsize: {width, height}, sizes: sizes)
+
+      assert %Dataset{transformed: transformed} =
+               Areal.do_transform(
+                 dataset,
+                 Enum.min_max(x),
+                 Enum.min_max(y),
+                 width,
+                 height,
+                 {0, 0}
+               )
+
+      assert Enum.all?(transformed, &match?({{_, _}, _}, &1))
     end
+
     test "zips transformed values with marker size if colors exist without sizes" do
-      x = [1,2,3,4,5]
+      x = [1, 2, 3, 4, 5]
       y = [10, 20, 30, 40, 50]
       colors = [1, 2, 3, 4, 5]
       width = 2
       height = 2
-      assert %Figure{axes: %{dataset: [%Dataset{marker_size: _marker_size} = dataset]}} = x|>Matplotex.scatter(y,figsize: {width, height}, colors: colors)
-      assert %Dataset{transformed: transformed} = Areal.do_transform(dataset, Enum.min_max(x), Enum.min_max(y),width, height, {0,0})
-      assert Enum.all?(transformed, &match?({{{_,_},_marker_size},_}, &1))
+
+      assert %Figure{axes: %{dataset: [%Dataset{marker_size: _marker_size} = dataset]}} =
+               x |> Matplotex.scatter(y, figsize: {width, height}, colors: colors)
+
+      assert %Dataset{transformed: transformed} =
+               Areal.do_transform(
+                 dataset,
+                 Enum.min_max(x),
+                 Enum.min_max(y),
+                 width,
+                 height,
+                 {0, 0}
+               )
+
+      assert Enum.all?(transformed, &match?({{{_, _}, _marker_size}, _}, &1))
     end
+
     test "zips transformed values with colors if the dataset contanis colors" do
-      x = [1,2,3,4,5]
+      x = [1, 2, 3, 4, 5]
       y = [10, 20, 30, 40, 50]
       colors = [1, 2, 3, 4, 5]
       width = 2
       height = 2
-      assert %Figure{axes: %{dataset: [dataset]}} = x|>Matplotex.scatter(y,figsize: {width, height}, colors: colors)
-      assert %Dataset{transformed: transformed} = Areal.do_transform(dataset, Enum.min_max(x), Enum.min_max(y),width, height, {0,0})
 
-      assert Enum.all?(transformed, &match?({{{_,_},_},_}, &1))
+      assert %Figure{axes: %{dataset: [dataset]}} =
+               x |> Matplotex.scatter(y, figsize: {width, height}, colors: colors)
 
+      assert %Dataset{transformed: transformed} =
+               Areal.do_transform(
+                 dataset,
+                 Enum.min_max(x),
+                 Enum.min_max(y),
+                 width,
+                 height,
+                 {0, 0}
+               )
+
+      assert Enum.all?(transformed, &match?({{{_, _}, _}, _}, &1))
     end
 
     test "zips both size and colors if the dataset contains size and color" do
-      x = [1,2,3,4,5]
+      x = [1, 2, 3, 4, 5]
       y = [10, 20, 30, 40, 50]
       sizes = [1, 2, 3, 4, 5]
       colors = [1, 2, 3, 4, 5]
       width = 2
       height = 2
-      assert %Figure{axes: %{dataset: [dataset]}} = x|>Matplotex.scatter(y,figsize: {width, height}, sizes: sizes, colors: colors)
-      assert %Dataset{transformed: transformed} = Areal.do_transform(dataset, Enum.min_max(x), Enum.min_max(y),width, height, {0,0})
 
-      assert Enum.all?(transformed, &match?({{{_,_},_},_}, &1))
+      assert %Figure{axes: %{dataset: [dataset]}} =
+               x |> Matplotex.scatter(y, figsize: {width, height}, sizes: sizes, colors: colors)
 
-    end
+      assert %Dataset{transformed: transformed} =
+               Areal.do_transform(
+                 dataset,
+                 Enum.min_max(x),
+                 Enum.min_max(y),
+                 width,
+                 height,
+                 {0, 0}
+               )
 
+      assert Enum.all?(transformed, &match?({{{_, _}, _}, _}, &1))
+    end
   end
-
-
 end

test/matplotex/figure/lead_test.exs

@@ -263,18 +263,22 @@ defmodule Matplotex.Figure.LeadTest do
 
   describe "transform_sizes/1" do
     test "converts sizes to equivalent radius to the buble" do
-      x = [1,2,3,4,5]
+      x = [1, 2, 3, 4, 5]
       y = [10, 20, 30, 40, 50]
       sizes = [1, 2, 3, 4, 5]
       width = 2
       height = 2
-      figure = x|>Matplotex.scatter(y,figsize: {width, height}, sizes: sizes)|> Lead.set_regions_areal()
+
+      figure =
+        x
+        |> Matplotex.scatter(y, figsize: {width, height}, sizes: sizes)
+        |> Lead.set_regions_areal()
 
       assert %Figure{axes: %{dataset: [%Dataset{sizes: transformed_sizes}]}} =
                Lead.transform_sizes(figure)
 
       assert length(transformed_sizes) == length(sizes)
-      assert Enum.sum(transformed_sizes) < (width * height) * 0.7
+      assert Enum.sum(transformed_sizes) < width * height * 1.5
     end
   end
 end