vil_pyramid_image_list.cxx

Go to the documentation of this file.

#include <algorithm>
#include <cmath>
#include <sstream>
#include "vil_pyramid_image_list.h"
//:
// \file
#include <cassert>
#ifdef _MSC_VER
#  include <vcl_msvc_warnings.h>
#endif
#include <vil/vil_stream_fstream.h>
#include <vil/vil_image_list.h>
#include <vil/vil_blocked_image_facade.h>
#include <vil/vil_cached_image_resource.h>
#include <vil/vil_new.h>
#include <vil/vil_load.h>
#include <vil/vil_copy.h>

//:Load a pyramid image.  The path should correspond to a directory.
//If not, return a null resource.
vil_pyramid_image_resource_sptr
vil_pyramid_image_list_format::make_input_pyramid_image(char const* directory)
{
  vil_image_list il(directory);
  std::vector<vil_image_resource_sptr> rescs = il.resources();
  if (rescs.size() < 2L)
    return nullptr;
  auto* pil = new vil_pyramid_image_list(rescs);
  pil->set_directory(directory);
  return pil;
}

vil_pyramid_image_resource_sptr
vil_pyramid_image_list_format::make_pyramid_output_image(char const* file)
{
  if (!vil_image_list::vil_is_directory(file))
    return nullptr;
  return new vil_pyramid_image_list(file);
}

static bool copy_base_resc(vil_image_resource_sptr const& base_image,
                           const std::string& full_filename,
                           char const* file_format,
                           vil_blocked_image_resource_sptr& copy)
{
  { //scope for closing resource
  //Create a new blocked base image resource
  std::cout << "Copying base resource\n";
  vil_blocked_image_resource_sptr brsc = blocked_image_resource(base_image);
  if (!brsc||brsc->size_block_i()%2!=0||brsc->size_block_i()%2!=0)
    brsc = new vil_blocked_image_facade(base_image);
  // handle case of RGBA as four planes
  vil_pixel_format fmt = vil_pixel_format_component_format(brsc->pixel_format());
  vil_blocked_image_resource_sptr out_resc =
    vil_new_blocked_image_resource(full_filename.c_str(),
                                   brsc->ni(), brsc->nj(),
                                   brsc->nplanes(),
                                   fmt,
                                   brsc->size_block_i(),
                                   brsc->size_block_j(),
                                   file_format);
  if (!out_resc)
    return false;
  for (unsigned int j = 0; j<brsc->n_block_j(); ++j)
    for (unsigned int i = 0; i<brsc->n_block_i(); ++i)
    {
      vil_image_view_base_sptr blk = brsc->get_block(i,j);
      if (!blk)
        return false;
      if (!out_resc->put_block(i, j, *blk))
        return false;
    }
  }//end scope for out resource
  //
  //reopen the resource for reading.
  vil_image_resource_sptr temp = vil_load_image_resource(full_filename.c_str());
  copy = blocked_image_resource(temp);
  return (bool)copy;
}

static std::string level_filename(std::string& directory, std::string& filename,
                                 float level)
{
  std::string slash;

#ifdef _WIN32
  slash =  "\\";
#else
  slash = "/";
#endif
  std::stringstream cs;
  cs << level;
  return directory + slash + filename + "_" + cs.str();
}

//: Construct pyramid image files in the directory
//  Each level has the same scale ratio (0.5) to the preceding level.
//  Level 0 is the original base image.
vil_pyramid_image_resource_sptr vil_pyramid_image_list_format::
    make_pyramid_image_from_base(char const* directory,
                                 vil_image_resource_sptr const& base_image,
                                 unsigned int nlevels,
                                 bool copy_base,
                                 char const* level_file_format,
                                 char const* filename
                                )
{
  if (!vil_image_list::vil_is_directory(directory))
    return nullptr;
  std::string d = directory;
  std::string fn = filename;
  std::string full_filename = level_filename(d,fn, 0.0f) + '.'+ level_file_format;
  vil_blocked_image_resource_sptr blk_base;
  if (copy_base)
  {
    if (!copy_base_resc(base_image, full_filename,
                        level_file_format, blk_base))
      return nullptr;
  }
  else
  {
    blk_base =
      blocked_image_resource(base_image);
    if (!blk_base)
      return nullptr;
  }
  //Create the other pyramid levels
  { //program scope to close resource files
    vil_image_resource_sptr image = blk_base.ptr();
    for (unsigned int L = 1; L<nlevels; ++L)
    {
      std::cout << "Decimating Level " << L << std::endl;
      full_filename = level_filename(d, fn, float(L)) + '.'+ level_file_format;
      image = vil_pyramid_image_resource::decimate(image,full_filename.c_str());
    }
  } //end program scope to close resource files
  vil_image_list il(directory);
  std::vector<vil_image_resource_sptr> rescs = il.resources();
  return new vil_pyramid_image_list(rescs);
}

///==============  start vil_pyramid_image_list  =========================
//comparison of level scales
static bool level_compare(pyramid_level* const l1, pyramid_level* const l2)
{
  assert(l1&&l2);
  return l1->image_->ni() > l2->image_->ni();
}


vil_pyramid_image_list::vil_pyramid_image_list() : directory_("")
{}

vil_pyramid_image_list::vil_pyramid_image_list(char const* directory) : directory_(directory)
{}

vil_pyramid_image_list::vil_pyramid_image_list(std::vector<vil_image_resource_sptr> const& images) : directory_("")
{
  for (const auto & image : images)
  {
    //if the resource is blocked use a cached access
    vil_blocked_image_resource_sptr brsc = blocked_image_resource(image);
    if (!brsc)
      brsc = new vil_blocked_image_facade(image);
    vil_cached_image_resource* cimr = new vil_cached_image_resource(brsc, 100);
    vil_image_resource_sptr ir = (vil_image_resource*)cimr;
    auto* level = new pyramid_level(ir);
    levels_.push_back(level);
  }
  //sort on image width
  std::sort(levels_.begin(), levels_.end(), level_compare);
  this->normalize_scales();
}

vil_pyramid_image_list::~vil_pyramid_image_list()
{
  auto nlevels = (unsigned int)(levels_.size());
  for (unsigned int i = 0; i<nlevels; ++i)
    delete levels_[i];
}

//: Assumes that the image in level 0 is the largest
void vil_pyramid_image_list::normalize_scales()
{
  auto nlevels = (unsigned int)(levels_.size());
  if (nlevels==0)
    return;
  levels_[0]->scale_ = 1.0f;
  if (nlevels==1)
    return;
  auto ni0 = static_cast<float>(levels_[0]->image_->ni());
  for (unsigned int i = 1; i<nlevels; ++i)
    levels_[i]->scale_ = static_cast<float>(levels_[i]->image_->ni())/ni0;
}

bool vil_pyramid_image_list::is_same_size(vil_image_resource_sptr const& image)
{
  unsigned int ni = image->ni(), nj = image->nj();
  for (unsigned int L = 0; L<this->nlevels(); ++L)
    if (levels_[L]->image_->ni()==ni&&levels_[L]->image_->nj()==nj)
      return true;
  return false;
}

bool
vil_pyramid_image_list::add_resource(vil_image_resource_sptr const& image)
{
  if (this->is_same_size(image))
    return false;

  auto* level = new pyramid_level(image);
  levels_.push_back(level);

  //is this the first image added?
  if (levels_.size() == 1)
    return true;
  //sort the pyramid
  std::sort(levels_.begin(), levels_.end(), level_compare);
  //normalize the scales
  this->normalize_scales();
  return true;
}

//: Find an appropriate filename extension for the image.
// If the size of the image lies between existing scales then use
// the fractional amount in the name
float
vil_pyramid_image_list::find_next_level(vil_image_resource_sptr const& image)
{
  unsigned int nlevels = this->nlevels();
  if (nlevels==0)
    return 0.0f;
  auto base_ni = static_cast<float>(levels_[0]->image_->ni());
  return static_cast<float>(image->ni())/base_ni;
}

//: This method copies the resource into the pyramid.
// Use add_resource if the existing resource is to be just inserted into the level stack.
bool vil_pyramid_image_list::put_resource(vil_image_resource_sptr const& image)
{
  if (this->is_same_size(image))
    return false;
  float level = this->find_next_level(image);
  std::string copy_name = "copyR";
  std::string file = level_filename(directory_,copy_name, level);
  std::string ffmt = "pgm";
  if (image->file_format())
    ffmt = image->file_format();
  file = file +'.'+ ffmt;
  unsigned int sbi = 0, sbj = 0;
  vil_blocked_image_resource_sptr bir = blocked_image_resource(image);
  if (bir)
  { sbi = bir->size_block_i(); sbj = bir->size_block_j(); }
  vil_image_resource_sptr copy;
  if (sbi==0||sbj==0)
  {
#ifdef VIL_USE_FSTREAM64
    vil_stream_fstream64* os = new vil_stream_fstream64(file.c_str(), "w");
#else //VIL_USE_FSTREAM64
    auto* os = new vil_stream_fstream(file.c_str(), "w");
#endif //VIL_USE_FSTREAM64
    copy = vil_new_image_resource(os, image->ni(), image->nj(),
                                  image->nplanes(), image->pixel_format(),
                                  ffmt.c_str());
  }
  else
    copy = vil_new_blocked_image_resource(file.c_str(),
                                          image->ni(), image->nj(),
                                          image->nplanes(),
                                          image->pixel_format(),
                                          sbi, sbj,
                                          ffmt.c_str()).ptr();
  if (!vil_copy_deep(image, copy))
    return false;
  return this->add_resource(copy);
}

//:find the level closest to the specified scale
pyramid_level* vil_pyramid_image_list::closest(const float scale) const
{
  auto nlevels = (unsigned int)(levels_.size());
  if (nlevels == 0)
    return nullptr;

  if (nlevels == 1)
    return levels_[0];
  float mind = 1.0e08f;//huge scale;
  unsigned int lmin = 0;
  for (unsigned int i = 0; i<nlevels; ++i)
  {
    float ds = std::fabs(std::log(levels_[i]->scale_ / scale));
    if (ds<mind)
    {
      mind = ds;
      lmin = i;
    }
  }
  pyramid_level* pl = levels_[lmin];
  if (pl)
    pl->cur_level_ = lmin;
  return pl;
}

vil_image_view_base_sptr
vil_pyramid_image_list::get_copy_view(unsigned int i0, unsigned int n_i,
                                      unsigned int j0, unsigned int n_j,
                                      unsigned int level) const
{
  if (level>=this->nlevels())
  {
    std::cerr << "pyramid_image_list::get_copy_view(.) level = "
             << level << " max level = "
             << this->nlevels() -1 << '\n';
    return nullptr;
  }
  pyramid_level* pl = levels_[level];
  float actual_scale = pl->scale_;

  float fi0 = actual_scale*i0, fni = actual_scale*n_i, fj0 = actual_scale*j0, fnj = actual_scale*n_j;
  //transform image coordinates by actual scale
  auto si0 = static_cast<unsigned int>(fi0);
  auto sni = static_cast<unsigned int>(fni);
  if (sni == 0) sni = 1;//can't have less than one pixel
  auto sj0 = static_cast<unsigned int>(fj0);
  auto snj = static_cast<unsigned int>(fnj);
  if (snj == 0) snj = 1;//can't have less than one pixel
  vil_image_view_base_sptr v = pl->image_->get_copy_view(si0, sni, sj0, snj);
  if (!v)
  {
    std::cerr << "pyramid_image_list::get_copy_view(.) level = "
             << level << "(i0,j0):("
             << i0 << ' ' << j0 << ") (ni, nj):("
             << n_i << ' ' << n_j << ")\n"
             << "Get copy view from level image failed\n";
    return nullptr;
  }
  return v;
}

//:return a view with image scale that is closest to scale.
vil_image_view_base_sptr
vil_pyramid_image_list::get_copy_view(unsigned int i0, unsigned int n_i,
                                      unsigned int j0, unsigned int n_j,
                                      const float scale,
                                      float& actual_scale) const
{
  //find the resource that is closest to the specified scale
  pyramid_level* pl = this->closest(scale);
  if (!pl)
  {
    actual_scale = 0;
    return nullptr;
  }
  actual_scale = pl->scale_;
  unsigned int level = pl->cur_level_;
  return this->get_copy_view(i0, n_i, j0, n_j, level);
}