ImageValueBar.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 "ImageValueBar.hh"
#include <Base/Math/Vector3.hh>
#include <Base/Image/ImageConvert.hh>
#include <Base/ImageUtils/ImageDraw.hh>


using namespace BIAS;
using namespace std;

template <class StorageType>
ImageValueBar<StorageType>::
ImageValueBar() : Image<StorageType>()
{
    model_ = ImageBase::CM_Grey;
    minDisplay_= minValue_ = 0.0;
    maxDisplay_= maxValue_ = 255.0;
    ticks_=10;
    unit_="mm";
}


template<class StorageType>
ImageValueBar<StorageType>::
~ImageValueBar() {
}


template<class StorageType>
void ImageValueBar<StorageType>::
Update(){
    unsigned width = this->GetWidth();
    unsigned height = this->GetHeight();
    if(width < 100){
        this->ReInit(100,height);
    }

    unsigned barArea = width-80;
    unsigned channels = this->GetChannelCount();
    this->FillImageWithConstValue(this->MaxSTValue());

    //std::cout<<"Update: dimension "<<width<<","<<height<<","<<channels<<std::endl;
    double step = (maxValue_-minValue_)/(double)height;
    //std::cout<<"Min, max, step "<<minValue_<<","<<maxValue_<<","<<step<<std::endl;


    StorageType **ida = this->GetImageDataArray();
    // check which desired output model is requested and
    // fill values
    switch(model_){
        case ImageBase::CM_Grey:
        {
            //go from top to bottom
            for(unsigned y =0;y<height;y++){
                for(unsigned x = 0;x<barArea;x++){
                    for(unsigned c=0;c<channels;c++){
                        ida[y][x*channels+c]  = (StorageType)(maxValue_- step*(double)y);
                    }
                }
            }
        }
        break;
        case ImageBase::CM_RGB:
            //go from top to bottom
            for(unsigned y =0;y<height;y++){
                for(unsigned x = 0;x<barArea;x++){
                    for(unsigned c=0;c<channels;c++){
                        ida[y][x*channels+c]  = (StorageType)(maxValue_- step*(double)y);
                    }
                }
            }
            break;
        case ImageBase::CM_HSV:
        {
            BIASWARN("This doesn't make sense right now, but maybe in the future?");
            BIAS::Vector3<float> rgbF(0,0,0);
            BIAS::Vector3<float> hsv(0,1,1);
            //go from top to bottom
            for(unsigned y =0;y<height;y++){
                for(unsigned x = 0;x<barArea;x++){
                    hsv[0] = (float)((height-y))/2;
                    ImageConvert::HSVToRGB(hsv[0],hsv[1],hsv[2],rgbF[0],rgbF[1],rgbF[2]);
                    for(unsigned c=0;c<channels;c++){
                        ida[y][x*channels+c] = StorageType(rgbF[c]);
                    }
                }
            }
        }
        break;
        default:
            BIASERR("Unimplemented!");
    }

    ////////////////////Draw ticks //////////////////
    int spacing = ((int)height)/ticks_;
    double stepDisplay = (maxDisplay_-minDisplay_)/(double)height;
    //std::cout<<"Min, max, step DISPLAY"<<minDisplay_<<","<<maxDisplay_<<","<<stepDisplay<<std::endl;
    for(int i=0;i<ticks_;i++){
        int startX = barArea;
        int startY = height-1-spacing*i;
        int stopX = barArea+5;
        int stopY = height-1-spacing*i;
        ImageDraw<StorageType>::Line(*this,startX,startY, //startx, starty
                                               stopX,stopY );//stopx, stopy
        int value = (int)rint(minDisplay_+stepDisplay*spacing*i);
        stringstream tx;
        tx<< value;
        tx<<unit_;
        //black
        const ColourRGB< StorageType > colorRGB(0, 0, 0);
        if(this->GetStorageType() == ImageBase::ST_float ||
             this->GetChannelCount() == 1)
        {
            ImageDraw<StorageType>::Text(*this,tx.str(),barArea+5,
                    (int)(height)-3-spacing*i,
                    colorRGB);//,CV_FONT_HERSHEY_COMPLEX_SMALL,0.7,0.7);
        }
        else{
            ImageDraw<StorageType>::TextIM(*this,tx.str(),barArea+5,
                                                                        (int)(height)-2-spacing*i,
                                                                        colorRGB);
        }
    }
}


#define INSTANCE_Image(type)\
template class BIASUtils_EXPORT ImageValueBar<type>;

// create instances
namespace BIAS{
INSTANCE_Image(unsigned char)
INSTANCE_Image(float)
#ifdef BUILD_IMAGE_INT
INSTANCE_Image(int)
#endif
#ifdef BUILD_IMAGE_CHAR
INSTANCE_Image(char)
#endif
#ifdef BUILD_IMAGE_SHORT
INSTANCE_Image(short)
#endif
#if defined(BUILD_IMAGE_USHORT)
INSTANCE_Image(unsigned short)
#endif
#ifdef BUILD_IMAGE_DOUBLE
INSTANCE_Image(double)
#endif
#ifdef BUILD_IMAGE_UINT
INSTANCE_Image(unsigned int)
#endif
}