`99db101`

fix stragglers (last item) to overlap in some dirs

Authored by

espadonne 6 months ago

SHA: 99db10172be79017ef45652095eb522542e0c38b
Parents: 13ba3ed
Tree: 96ece75

1 changed file

Status	File	+	-
M	`src/layout/squarified.f90`	26	16

src/layout/squarified.f90modified

        pivot_area%x = bounds%x
        pivot_area%y = bounds%y
        pivot_area%width = bounds%width
--      pivot_area%height = int((real(pivot_size, real64) / real(total_size, real64)) * real(bounds%height, real64))
++      pivot_area%height = nint((real(pivot_size, real64) / real(total_size, real64)) * real(bounds%height, real64))
        pivot_area%height = max(30, min(pivot_area%height, bounds%height - 30))
        remaining_area%x = bounds%x
      else if (spiral_direction == 1) then
        ! RIGHT: Pivot on right, remaining on left
--      pivot_area%width = int((real(pivot_size, real64) / real(total_size, real64)) * real(bounds%width, real64))
++      pivot_area%width = nint((real(pivot_size, real64) / real(total_size, real64)) * real(bounds%width, real64))
        pivot_area%width = max(30, min(pivot_area%width, bounds%width - 30))
        pivot_area%x = bounds%x + bounds%width - pivot_area%width
        pivot_area%y = bounds%y
      else if (spiral_direction == 2) then
        ! BOTTOM: Pivot at bottom, remaining above
--      pivot_area%height = int((real(pivot_size, real64) / real(total_size, real64)) * real(bounds%height, real64))
++      pivot_area%height = nint((real(pivot_size, real64) / real(total_size, real64)) * real(bounds%height, real64))
        pivot_area%height = max(30, min(pivot_area%height, bounds%height - 30))
        pivot_area%x = bounds%x
        pivot_area%y = bounds%y + bounds%height - pivot_area%height
        ! LEFT: Pivot on left, remaining on right
        pivot_area%x = bounds%x
        pivot_area%y = bounds%y
--      pivot_area%width = int((real(pivot_size, real64) / real(total_size, real64)) * real(bounds%width, real64))
++      pivot_area%width = nint((real(pivot_size, real64) / real(total_size, real64)) * real(bounds%width, real64))
        pivot_area%width = max(30, min(pivot_area%width, bounds%width - 30))
        pivot_area%height = bounds%height
        ! Calculate dynamic minimum based on available space
        ! If we have N items and W width, ensure each item gets at most W/N
        available_space = bounds%width
--      dynamic_min = max(2, available_space / actual_num_nodes)  ! At least 2 pixels
++      dynamic_min = max(1, available_space / actual_num_nodes)  ! At least 1 pixel per item
--      dynamic_min = min(dynamic_min, 10)  ! But prefer 10 if space allows
        ! Stack left-to-right
        offset = bounds%x
        do i = 1, actual_num_nodes
          if (i < actual_num_nodes) then
--          item_size = int((real(nodes(i)%size, real64) / real(actual_total_size, real64)) * real(bounds%width, real64))
++          ! Calculate proportional size
++          item_size = nint((real(nodes(i)%size, real64) / real(actual_total_size, real64)) * real(bounds%width, real64))
++          ! Apply minimum, but check we won't overflow
            item_size = max(dynamic_min, item_size)
++          ! Ensure we don't exceed remaining space
++          item_size = min(item_size, (bounds%x + bounds%width) - offset - (actual_num_nodes - i))
          else
--          ! Last item gets remaining space (prevents overflow)
++          ! Last item gets ALL remaining space (prevents gaps/overlaps)
--          item_size = bounds%x + bounds%width - offset
++          item_size = (bounds%x + bounds%width) - offset
--          item_size = max(1, item_size)  ! Ensure at least 1 pixel
          end if
++        ! Ensure at least 1 pixel
++        item_size = max(1, item_size)
++
          nodes(i)%bounds%x = offset
          nodes(i)%bounds%y = bounds%y
          nodes(i)%bounds%width = item_size
      else
        ! Calculate dynamic minimum based on available space
        available_space = bounds%height
--      dynamic_min = max(1, available_space / actual_num_nodes)  ! At least 1 pixel
++      dynamic_min = max(1, available_space / actual_num_nodes)  ! At least 1 pixel per item
--      dynamic_min = min(dynamic_min, 3)  ! But prefer 3 if space allows
        ! Stack top-to-bottom
        offset = bounds%y
        do i = 1, actual_num_nodes
          if (i < actual_num_nodes) then
--          item_size = int((real(nodes(i)%size, real64) / real(actual_total_size, real64)) * real(bounds%height, real64))
++          ! Calculate proportional size
++          item_size = nint((real(nodes(i)%size, real64) / real(actual_total_size, real64)) * real(bounds%height, real64))
++          ! Apply minimum, but check we won't overflow
            item_size = max(dynamic_min, item_size)
++          ! Ensure we don't exceed remaining space
++          item_size = min(item_size, (bounds%y + bounds%height) - offset - (actual_num_nodes - i))
          else
--          ! Last item gets remaining space (prevents overflow)
++          ! Last item gets ALL remaining space (prevents gaps/overlaps)
--          item_size = bounds%y + bounds%height - offset
++          item_size = (bounds%y + bounds%height) - offset
--          item_size = max(1, item_size)  ! Ensure at least 1 pixel
          end if
++        ! Ensure at least 1 pixel
++        item_size = max(1, item_size)
++
          nodes(i)%bounds%x = bounds%x
          nodes(i)%bounds%y = offset
          nodes(i)%bounds%width = bounds%width