biasjoinimages.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <Base/Image/Image.hh>
#include <stdio.h>
#include <map>
#include <string>
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageConvert.hh>
#include <Utils/Param.hh>
#include <Filter/Rescale.hh>
#include <Utils/IOUtils.hh>

using namespace BIAS;
using namespace std;

BIAS::Param params;

void usage()
{
  cout<<"Takes up to four image lists and creates new images containing all side by side"<<endl;
  cout<<"\n\n biasjoinimages imagelist1 imagelist2 <imagelist3 imagelist4>\n\n"<<endl;
  params.Usage();
}

/**
    @file 
    @ingroup g_tools
    @brief Joins up to 4 images for video production. See biasjoinimages.cpp
    @author ischiller
*/
int main (int argc, char *argv[])
{
  int ret = 0;
  bool bfourImages = false;
  string *list1 = params.AddParamString("list1","First list of images","",'1');
  string *list2 = params.AddParamString("list2","Second list of images","",'2');
  string *list3 = params.AddParamString("list3","Third list of images","",'3');
  string *list4 = params.AddParamString("list4","Forth list of images","",'4');
  double *rescaleFactor = params.AddParamDouble("RescaleFactor","Rescale factor, 2 means half size",1.0,0.0,10000,'r');

  bool r = IOUtils::ParseCommandLineEvalHelp(params,argc,argv);
  if(!r || *list1 == "" ||*list1 == ""){
    usage(); return 0;
  }

  std::vector<std::string> images1,images2;
  ret = Param::ParseListFile(*list1, images1);
  if(ret < 0){ BIASERR("Could not parse list file"<<*list1); return 0;}
  ret = Param::ParseListFile(*list2, images2);
  if(ret < 0){ BIASERR("Could not parse list file"<<*list2); return 0;}

  std::vector<std::string> images3, images4;
  unsigned int width, height;

  if(*list3 != "" && *list4!=""){
    bfourImages = true;
    ret = Param::ParseListFile(*list3, images3);
    if(ret < 0){ BIASERR("Could not parse list file"<<*list3); return 0;}
    ret = Param::ParseListFile(*list4, images4);
    if(ret < 0){ BIASERR("Could not parse list file"<<*list4); return 0;}
  }

  BIAS::ImageBase image1,image2,image3,image4;
  BIAS::Image<unsigned char> imageUC,image1UC,image2UC,image3UC,image4UC;
  BIAS::Image<unsigned char> image11,image22,image33,image44;
  BIAS::Image<unsigned char> destImage;
  int dImageIndex =102;
  for(unsigned int i=0;i< images1.size();i++){
    //Clean image to enable reinit
    if(!destImage.IsEmpty())  destImage.Release();

    cout<<"Image "<< dImageIndex<<endl;
    BIAS::ImageIO::Load(images1[i], image1);
    BIAS::ImageIO::Load(images2[i], image2);
    //save dimension
    width = image1.GetWidth();
    height = image1.GetHeight();
    //convert ST
    if(image1.GetStorageType() != BIAS::ImageBase::ST_unsignedchar){
      (BIAS::Image<float>(image1)).ScaleShiftBetween(0,255);
      BIAS::ImageConvert::ConvertST(image1, image11, BIAS::ImageBase::ST_unsignedchar);
    }
    else
      image11 = image1;

    // 2. image
    if(image2.GetStorageType() != BIAS::ImageBase::ST_unsignedchar){
      ((BIAS::Image<float>)(image2)).ScaleShiftBetween(0,255);
      BIAS::ImageConvert::ConvertST(image2, image22, BIAS::ImageBase::ST_unsignedchar);
    }
    else
      image22 = image2;

    //  rescale all images to same size
    if(image22.GetWidth() != width || image22.GetHeight() != height){
      BIAS::Rescale<unsigned char,unsigned char> rescale;
      rescale.Upsample(image22,image2UC,width,height);
      image22 = image2UC;
    }

    //Convert all to RGB
    BIAS::ImageConvert::ToRGB(image11,imageUC);
    BIAS::ImageBase::EColorModel colorModel = imageUC.GetColorModel();
    BIAS::ImageConvert::Convert(image22, image2UC,colorModel);

    //////////////////////////////////////////////////////////////////
    if(bfourImages){
      BIAS::ImageIO::Load(images3[i], image3);
      BIAS::ImageIO::Load(images4[i], image4);
      if(image3.GetStorageType() != BIAS::ImageBase::ST_unsignedchar){
        ((BIAS::Image<unsigned char>)(image3)).ScaleShiftBetween(0,255);
        BIAS::ImageConvert::ConvertST(image3, image33, BIAS::ImageBase::ST_unsignedchar);
      }
      else image33 = image3;

      if(image33.GetWidth() != width || image33.GetHeight() != height){
        BIAS::Rescale<unsigned char,unsigned char> rescale;
        rescale.Upsample(image33,image3UC,width,height);
        image33 = image3UC;
      }


      if(image4.GetStorageType() != BIAS::ImageBase::ST_unsignedchar){
        ((BIAS::Image<unsigned char>)(image4)).ScaleShiftBetween(0,255);
        BIAS::ImageConvert::ConvertST(image4, image44, BIAS::ImageBase::ST_unsignedchar);
      }
      else image44 = image4;

      if(image44.GetWidth() != width || image44.GetHeight() != height){
        BIAS::Rescale<unsigned char,unsigned char> rescale;
        rescale.Upsample(image44,image4UC,image44.GetWidth()*4,image44.GetHeight()*4);
        image44 =image4UC;
      }

      BIAS::ImageConvert::Convert(image33, image3UC,colorModel);
      BIAS::ImageConvert::Convert(image44, image4UC,colorModel);

      int destW = 0;
      int destH = 0;
      //width
      if((image11.GetWidth() + image22.GetWidth()) > (image33.GetWidth()+ image44.GetWidth()) ){
        destW = image11.GetWidth() + image22.GetWidth();
      }
      else
        destW = image33.GetWidth()+ image44.GetWidth();

      //height
      if((image11.GetHeight() + image33.GetHeight()) >(image22.GetHeight()+ image44.GetHeight()) ){
        destH = image11.GetHeight() + image33.GetHeight();
      }
      else
        destH = image22.GetHeight()+ image44.GetHeight();

      destImage.Init(destW,destH,3);
    }//bfourimages
    else{
      destImage.Init(image11.GetWidth()+image22.GetWidth(),
                     image11.GetHeight(),3);
    }

    //paste images to new image
    unsigned ulx=0,uly=0,lrx=image11.GetWidth(),lry=image11.GetHeight();
    int xoffset1=0, yoffset1=0;

    destImage.SetROICorners(ulx,uly,lrx,lry);
    destImage.Paste2ROI(imageUC);


    xoffset1 = (image11.GetWidth() - image22.GetWidth())/2;
    yoffset1 = (image11.GetHeight() - image22.GetHeight())/2;
    //cout<<"Xoffset:"<<xoffset1<<endl;
    //cout<<"Yoffset:"<<yoffset1<<endl;

    ulx = image11.GetWidth()+xoffset1;
    uly = yoffset1;
    lrx = image11.GetWidth()+image22.GetWidth()+xoffset1;
    lry = image22.GetHeight()+yoffset1;

//     ulx = xoffset1;
//     uly = image11.GetHeight()+ yoffset1;
//     lrx = image11.GetWidth()+xoffset1;
//     lry = image11.GetHeight()+image22.GetHeight()+yoffset1;
    destImage.SetROICorners(ulx,uly,lrx,lry);

    destImage.Paste2ROI(image2UC);

    if(bfourImages){
      unsigned ulx=0,uly=0,lrx=0,lry=0;
      //int xoffset2=0, yoffset2=0;
      ulx = 0;
      uly = image11.GetHeight();
      lrx =  image33.GetWidth();
      lry = image11.GetHeight()+image33.GetHeight();

      destImage.SetROICorners(ulx,uly,lrx,lry);
      destImage.Paste2ROI(image3UC);

      //xoffset2 = (image33.GetWidth() - image44.GetWidth())/2;
      //cout<<"Xoffset2:"<<xoffset2<<endl;
      //yoffset2 = (image33.GetHeight() - image44.GetHeight())/2;
      //cout<<"Yoffset2:"<<yoffset2<<endl;

      ulx = image33.GetWidth()+65;
      uly = image11.GetHeight()+150;
      lrx = image33.GetWidth()+image44.GetWidth()+65;
      lry = image11.GetHeight()+image44.GetHeight()+150;
      //cout<<"UL:"<<ulx<<","<<uly<<endl;
      //cout<<"LR:"<<lrx<<","<<lry<<endl;

      destImage.SetROICorners(ulx,uly,lrx,lry);

      destImage.Paste2ROI(image4UC);

    }
    dImageIndex++;

    if(*rescaleFactor != 1.0){
      BIAS::Rescale<unsigned char,unsigned char> rescaler;
      BIAS::Image<unsigned char> tmp;
      tmp.SetColorModel(colorModel);
      destImage.UnsetROI();
      rescaler.SetFactor(*rescaleFactor);
      rescaler.Filter(destImage,tmp);
      stringstream name2;
      name2<<"joined_rescale"<<BIAS::FileHandling::LeadingZeroString(dImageIndex,5)<<".png";

      BIAS::ImageIO::Save(name2.str(),tmp);
      cout<<"saved:"<<name2.str()<<endl;
    }
    else{
      stringstream name;
      name<<"joined_"<<BIAS::FileHandling::LeadingZeroString(dImageIndex,5)<<".png";
      BIAS::ImageIO::Save(name.str(),destImage);
      cout<<"saved:"<<name.str()<<endl;
    }
  }

}