biasinsert.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/Common/LeakChecking.h>

#include "Base/Image/ImageIO.hh"
#include "Base/Image/ImageConvert.hh"
#include "Filter/Rescale.hh"
#include "Utils/Param.hh"

using namespace BIAS;
using namespace std;


/**
   @file
   @ingroup g_tools
   @brief program for inserting an image into another, see biasinsert.cpp
   @author grest 04/05 */
int main(int argc, char  *argv[])
{
    Param params;
    params.DisableDestructorWarning();
    params.AddParamInt("tlx","top left insert x-position",-1,-1,10000,'x');    
    params.AddParamInt("tly","top left insert y-position",-1,-1,10000,'y');

    params.AddParamInt("xsize","pixel size of insertion in x-direction"
        " defaults to same",-1,-1,10000,'X');

    if (argc<3) {
        cout<<"usage:"<<argv[0]<<" <img> <imgToInsert> [resultimage]"<<endl;
        cout<<endl<<
            "       inserts the <imgToinsert> into <img> at the specified"<<
            " position, the position can be anyone! "<<endl<<
            "       default is right next to <img>"<<endl<<
            "       [resultImg] optional mip or ppm image"
            " , default: result is written to result.mip"<<
            endl<<endl;
        params.Usage();
        return 0;
    }
    int nextParam = params.ParseCommandLine(argc,argv);

    BIAS::ImageBase img, imgToIns,imgRescaled;
    if (ImageIO::Load(argv[nextParam],img)!=0) {
        cerr<<"error loading:"<<argv[nextParam]<<endl;
    }
    nextParam++;
    if (ImageIO::Load(argv[nextParam],imgToIns)!=0) {
        cerr<<"error loading:"<<argv[nextParam]<<endl;
    }

    if ( (img.GetStorageType()!=ImageBase::ST_unsignedchar) || 
        (imgToIns.GetStorageType()!=ImageBase::ST_unsignedchar) ) {
            cerr<<"only implemented for unsigned char images yet"<<endl;
            exit(-1);
        }
        if ( (img.GetColorModel()!=imgToIns.GetColorModel() ) ) {
            cerr<<"WARNING: colormodels do not match"<<endl<<
                "         converting <imgToinsert> to:"<<int(img.GetColorModel()) <<endl;   
            BIAS::ImageBase dummy;
            if (ImageConvert::Convert(imgToIns,dummy,img.GetColorModel()) !=0 ) {
                cerr<<"couldn't convert, exiting"<<endl;
                exit(-1);
            }
            imgToIns=dummy;
        }

        nextParam++;
        std::string resultFile;
        if (nextParam<argc) {
            resultFile=argv[nextParam];    
        } else resultFile="result.mip";

        double insertionSize= *params.GetParamInt("xsize");
        Image<unsigned char> scaledImg(imgToIns), resultImg(imgToIns);
        if (insertionSize!=-1) {
            Rescale<unsigned char, unsigned char>  scaler;
            scaler.SetFactor((double)imgToIns.GetWidth()/ insertionSize);
            scaler.Filter(resultImg,scaledImg);
        }
        int insertionX= *params.GetParamInt("tlx");
        if (insertionX==-1) insertionX=img.GetWidth();
        int insertionY= *params.GetParamInt("tly");
        if (insertionY==-1) insertionY=0;

        int resultXSize= insertionX + scaledImg.GetWidth();
        if ( resultXSize<(int)img.GetWidth() ) 
            resultXSize=img.GetWidth();
        int resultYSize= insertionY + scaledImg.GetHeight();
        if ( resultYSize<(int)img.GetHeight() ) 
            resultYSize=img.GetHeight();

        resultImg.Release();
        resultImg.Init(resultXSize,resultYSize,img.GetChannelCount());
        resultImg.SetColorModel(img.GetColorModel());
        resultImg.SetROI(0,0, img.GetWidth(), img.GetHeight());
        resultImg.Paste2ROI(img);
        resultImg.SetROI(insertionX,insertionY,
            insertionX+scaledImg.GetWidth(), 
            insertionY+scaledImg.GetHeight());
        resultImg.Paste2ROI(scaledImg);

        if (resultFile.find(".ppm") != string::npos) {
            ImageIO::Save(resultFile,resultImg,ImageIO::FF_ppm);
            cout<<"resulting ppm-image written to "<<resultFile<<endl;
        } else {
            //ImageIO::Save(resultFile,resultImg);
            ImageIO::Save(resultFile,resultImg);
            cout<<"resulting mip-image written to "<<resultFile<<endl;
        }    
    return 0;
}