def _arrays_to_sections(self, arrays):
    '''
    input: unprocessed numpy arrays.
    returns: columns of the size that they will appear in the image, not scaled
             for display. That needs to wait until after variance is computed.
    '''
    sections = []
    sections_to_resize_later = {}
    show_all = self.config['show_all']
    image_width = self._determine_image_width(arrays, show_all)

    for array_number, array in enumerate(arrays):
      rank = len(array.shape)
      section_height = self._determine_section_height(array, show_all)

      if rank == 1:
        section = np.atleast_2d(array)
      elif rank == 2:
        section = array
      elif rank == 4:
        section = self._reshape_conv_array(array, section_height, image_width)
      else:
        section = self._reshape_irregular_array(array,
                                                section_height,
                                                image_width)
      # Only calculate variance for what we have to. In some cases (biases),
      # the section is larger than the array, so we don't want to calculate
      # variance for the same value over and over - better to resize later.
      # About a 6-7x speedup for a big network with a big variance window.
      section_size = section_height * image_width
      array_size = np.prod(array.shape)

      if section_size > array_size:
        sections.append(section)
        sections_to_resize_later[array_number] = section_height
      else:
        sections.append(im_util.resize(section, section_height, image_width))

    self.sections_over_time.append(sections)

    if self.config['mode'] == 'variance':
      sections = self._sections_to_variance_sections(self.sections_over_time)

    for array_number, height in sections_to_resize_later.items():
      sections[array_number] = im_util.resize(sections[array_number],
                                              height,
                                              image_width)
    return sections