biasrescale.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 <Base/Image/ImageConvert.hh>
#include <Base/Image/ImageIO.hh>
#include <Image/Camera.hh>
#include <Utils/IOUtils.hh>
#include <Utils/Param.hh>
#include <Filter/Rescale.hh>
#include <Base/Common/FileHandling.hh>

using namespace std;
using namespace BIAS;


/**
    @file
    @ingroup g_tools
    @brief rescales images by given ratio (including projection parameters), see  biasrescale.cpp
    @author fkellner
*/
int main(int argc, char* argv[]) {

    Param p(true);
    double *ratio = p.AddParamDouble("ratio", "rescale ratio", 2.0, 0.1, 1000.0, 'r');

    Vector<int> *newsize = p.AddParamVecInt("size", "new size, (0 0) will use ratio", "0 0", 's');

    string *input = p.AddParamString("input", "input image or image list", "", 'i');
    string *output = p.AddParamString("output", "output image", "", 'o');

    if(!IOUtils::ParseCommandLineEvalHelp(p, argc, argv) )
        return 0;

    if(*input ==""){
        BIASERR("Give input image with -i option");
        return -1;
    }
    if(*output ==""){
        BIASERR("Give ouput image with -o option");
        return -1;
    }


    bool typeF = false;
    bool listMode = false;

    Camera<unsigned char> in;
    Camera<unsigned char> out;
    Rescale<unsigned char, unsigned char> scaler;
    scaler.SetBorderHandling(FilterBase<unsigned char, unsigned char>::TBH_same);
    scaler.SetFactor(*ratio);

    Camera<float> fin;
    Camera<float> fout;
    Rescale<float, float> fscaler;
    fscaler.SetBorderHandling(FilterBase<unsigned char, unsigned char>::TBH_same);
    fscaler.SetFactor(*ratio);

    Projection pIn;
    ImageBase inBase;

    //check for an image list
    std::string  dir;
    std::string  base;
    std::string  suffix;
    vector<string> intFiles;

    BIAS::FileHandling::SplitName(*input,dir,base,suffix);
    //if suffix is list handle list
    if(suffix==".lst"){
        int res = BIAS::Param::ParseListFile(*input,intFiles );
        if(res==0) listMode=true;   
        else {
            BIASERR("Input suggest list of images, but parsing the list failes.");
            return -1;
        }
    } 
    else //not a list, just pudh back one image
        intFiles.push_back(*input);

    // now go over vector of image names
    for(unsigned i=0;i<intFiles.size();i++){
        ImageIO::Load(intFiles[i], inBase);

        if (inBase.GetStorageType()==ImageBase::ST_float) {
            IOUtils::LoadCamera(&intFiles[i], fin, pIn);
            typeF = true;
        }
        else if(inBase.GetStorageType()==ImageBase::ST_unsignedchar) {
            IOUtils::LoadCamera(&intFiles[i], in, pIn);
            typeF=false;
        }
        else{
            BIASERR("Unhandled image storage type, please add switch.");
            return -1;
        }
        //check if we scale to a new size or with a factor
        //scale by factor
        if ((*newsize)[0] == 0 || ((*newsize)[1] == 0)) {

            if (!pIn.IsEmpty())
                pIn.Rescale(float(*ratio));

            if (typeF) {
                fscaler.Filter(fin, fout);
            } else {
                scaler.Filter(in, out);
            }

        }//end if ((*newsize)[0] == 0 || ((*newsize)[1] == 0)) {
        //scale to new size
        else {
            int w = in.GetWidth();
            int h = in.GetWidth();
            if ((*newsize)[0] > w && (*newsize)[1] > h) {
                if (typeF) {
                    fscaler.Upsample(fin, fout, (*newsize)[0], (*newsize)[1]);
                } else {
                    scaler.Upsample(in, out, (*newsize)[0], (*newsize)[1]);
                }
            } else if ((*newsize)[0] <= w && (*newsize)[1] <= h) {
                if (typeF) {
                    fscaler.Downsample(fin, fout, (*newsize)[0], (*newsize)[1]);
                } else {
                    scaler.Downsample(in, out, (*newsize)[0], (*newsize)[1]);
                }
            } else {
                cout << "can only Up- or Downsample" << endl;
            }
            if (!pIn.IsEmpty()) {
                cout << "WARNING: Projections are only scaled in rescale-by-ratio-mode. Will leave ProjectionParameters as they are" << endl;
            }
        }

        string outputFile=*output;

        if(listMode){
            BIAS::FileHandling::SplitName(*output,dir,base,suffix);
            stringstream str;
            str<<dir<<base<<"-"<<FileHandling::LeadingZeroString(i,5)<<suffix;
            outputFile = str.str();
        }
        
        if (!pIn.IsEmpty()) {
            if (typeF) {
                fout.UnsetROI();
                IOUtils::SaveCamera(outputFile, fout, pIn);
            } else {
                out.UnsetROI();
                IOUtils::SaveCamera(outputFile, out, pIn);
            }
        } else {
            if (typeF) {
                fout.UnsetROI();
                IOUtils::SaveCamera(outputFile, fout);
            } else {
                out.UnsetROI();
                IOUtils::SaveCamera(outputFile, out);
            }
        }
    }
    return 0;
}