ImagePackage.cpp

#include <Image/ImagePackage.hh>

using namespace std;
using namespace BIAS;

ImagePackage::ImagePackage() {
  bOpen_ = false;
  bReadMode_ = false;
  fileInfos_.clear();
  ifs_.clear();

}

ImagePackage::~ImagePackage() {
  if (bOpen_)
    Close();
}


int ImagePackage::Create(const string filename, unsigned int num) {
  filename_ = filename;
  fileNum_ = num;
  string fn = filename + FileHandling::LeadingZeroString(fileNum_, 4) + ".pack";
  cout << fn << endl;
  ofs_.open(fn.c_str(), ios::binary);
  if (ofs_.good()) {
    bOpen_ = true;
    bReadMode_ = false;
  }
  return 0;
}

int ImagePackage::AddImage(const ImageBase image, const string filename) {
  string fname = filename;
  if (fname.rfind("/")!=string::npos) {
    fname = fname.substr(fname.rfind("/")+1);
  }
  if (fname.rfind("\\")!=string::npos) {
    fname = fname.substr(fname.rfind("\\")+1);
  }
  unsigned int w = image.GetWidth();
  unsigned int h = image.GetHeight();
  unsigned int c = image.GetChannelCount();
  unsigned int b = image.GetDepth();
  IPImageHeader ipih;
  ipih.len_pixeldata = w*h*c*b;
  ipih.len_filename = fname.length();
  stringstream metadata;
  image.GetMetaData()->WriteBinary(metadata);
  ipih.len_metadata = metadata.str().length();

  ofs_ << ipih;
  ofs_ << fname;
  ofs_ << image;
  image.GetMetaData()->WriteBinary(ofs_);

  // 1GB file size reached
  if (ofs_.tellp() > 1073741824) {
    Close();
    Create(filename_, ++fileNum_);
  }
  return 0;
}


int ImagePackage::Open(const string filename) {
  filename_ = filename;
  if (filename_.find("0001.pack") != string::npos) {
    filename_ = filename_.substr(0,filename_.find("0001.pack"));
  }
  fileNum_ = 0;
  ifstream *test;
  bool exist = true;
  while (exist) {
    fileNum_++;
    string fn = filename_ + FileHandling::LeadingZeroString(fileNum_, 4) + ".pack";
    test = new ifstream;
    test->open(fn.c_str(), ios::binary);
    if (test->good()) {
      ifs_.push_back(test);
      bOpen_ = true;
      bReadMode_ = true;
    } else {
      exist = false;
    }
  }
  currentImg_ = 0;
  currentFile_ = 0;
  return 0;
}

int ImagePackage::GetImage(const int imageNum, ImageBase &image, string &filename) {

  while (imageNum < currentImg_) {
    if (GetPrevImage(image, filename)!=0) {
      cout << "GetImage: invalid image number" << endl;
      return -1;
    }
  }
  while (imageNum > currentImg_) {
    if (GetNextImage(image, filename)!=0) {
      cout << "GetImage: invalid image number" << endl;
      return -1;
    }
  }

//  IPFileInfo ipf = fileInfos_[currentImg_];
//  ifs_[ipf.fileNum]->seekg(ipf.offset);
  int ret = GetNextImage(image, filename);
  return ret;
}

int ImagePackage::GetNextImage(ImageBase &image, string &filename) {
  if (!image.IsEmpty())
    image.Release(true);
  ifs_[currentFile_]->peek();
  if (ifs_[currentFile_]->eof()) {
    if ((unsigned int)currentFile_+1<ifs_.size()) {
      currentFile_++;
    } else {
      return -1;
    }
  }
  
  if (ifs_[currentFile_]->good() == false) {
    BIASERR("file is corrupt. maybe not closed correctly?");
    return 1;
  }

  if ((int)fileInfos_.size()<=currentImg_) {
    IPFileInfo ipf;
    fileInfos_.push_back(ipf);
  }

  IPImageHeader ipih;
  fileInfos_[currentImg_].fileNum = (unsigned char) currentFile_;
  fileInfos_[currentImg_].offset = (unsigned long) ifs_[currentFile_]->tellg();
  *ifs_[currentFile_] >> ipih;

  if (ifs_[currentFile_]->good() == false) {
    BIASERR("file is corrupt. maybe not closed correctly?");
    return 1;
  }

  filename = "";
  if (ipih.len_filename>0) {
    stringstream fnamestream;
    for (unsigned int i=0;i<ipih.len_filename; i++) {
      char c;
      ifs_[currentFile_]->get(c);
      fnamestream.put(c);
    }
    filename = fnamestream.str();
    if (filename.find(".mip") == string::npos) {
      filename +=".mip";
    }
    fileInfos_[currentImg_].fileName = filename;
  } else {
    fileInfos_[currentImg_].fileName = filename_ + FileHandling::LeadingZeroString(currentImg_, 5) + ".mip";
  }
  *ifs_[currentFile_] >> image;
  if (ifs_[currentFile_]->good() == false) {
    BIASERR("file is corrupt. maybe not closed correctly?");
    return 1;
  }

  if (ipih.len_metadata>0) {
    stringstream metastream;
    for (unsigned int i=0;i<ipih.len_metadata; i++) {
      char c;
      ifs_[currentFile_]->get(c);
      metastream.put(c);
    }
    metastream >> *image.GetMetaData();
  }
  if (ifs_[currentFile_]->good() == false) {
    BIASERR("file is corrupt. maybe not closed correctly?");
    return 1;
  }

  currentImg_++;
  return 0;
}

int ImagePackage::GetPrevImage(ImageBase &image, string &filename) {
  if (currentImg_ < 1)
    return -1;
  currentImg_--;
  IPFileInfo ipf = fileInfos_[currentImg_];
  currentFile_ = ipf.fileNum;
  ifs_[currentFile_]->seekg(ipf.offset);
  GetNextImage(image, filename);
  ifs_[currentFile_]->seekg(ipf.offset);
  currentImg_--;
  return 0;
}

int ImagePackage::WriteSingleImage(const unsigned int imageNum, const string filename) {
  ImageBase image;

  while (imageNum >= fileInfos_.size()) {
    string tmp;
    if (GetNextImage(image, tmp)!=0) {
      cout << "WriteSingleImage: invalid image number" << endl;
      return -1;
    }
  }

  IPFileInfo ipf = fileInfos_[imageNum];
  unsigned int fidx = ipf.fileNum;
  unsigned long int curpos = (unsigned long) ifs_[fidx]->tellg();
  ifs_[fidx]->seekg(ipf.offset);
  string fname;
  GetNextImage(image, fname);
  ImageIO::Save(fname, image);
  ifs_[fidx]->seekg(curpos);
  return 0;
}

int ImagePackage::WriteAllImages(const string filename) {
  for (unsigned int i=0;i<ifs_.size();i++) {
    ifs_[i]->seekg(0);
  }
  ImageBase myImg;
  string fname;
  int len = filename.length();
  int n = 0;
  currentImg_ = 0;
  while (GetNextImage(myImg, fname)==0) {
    if (len>0) {
      fname = filename + FileHandling::LeadingZeroString(++n,5) + ".mip";
    }
    cout << "ImagePackage saving: " << fname << endl;
    ImageIO::Save(fname, myImg);
  }

  return 0;
}

int ImagePackage::Close() {
  if (bOpen_) {
    if (bReadMode_)
      for (unsigned int i=0;i<ifs_.size();i++)
        ifs_[i]->close();
    else {
      ofs_.close();
    }
    bOpen_ = false;
  } else {
    BIASWARN("closing non-open image package");
  }
  return 0;
}