---

image.cpp

/*=============================================================================
        File: image.cpp
     Purpose:
    Revision: $Id: image.cpp,v 1.4 2003/01/13 19:41:03 philosophil Exp $
  Created by:    Philippe Lavoie          (3 Oct, 1996)
 Modified by: 

 Copyright notice:
          Copyright (C) 1996-1997 Philippe Lavoie
 
          This library is free software; you can redistribute it and/or
          modify it under the terms of the GNU Library General Public
          License as published by the Free Software Foundation; either
          version 2 of the License, or (at your option) any later version.
 
          This library 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
          Library General Public License for more details.
 
          You should have received a copy of the GNU Library General Public
          License along with this library; if not, write to the Free
          Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
=============================================================================*/

#ifndef _PLIB_IMAGE_SOURCE
#define _PLIB_IMAGE_SOURCE

#include "image.h"
#include <stdio.h>

namespace PLib {

template <class T>
void MatrixImage<T>::drawLine(int i1, int j1, int i2, int j2, T color){
  int i,j ;
  double mx,b ;
  if(i1<0 || j1<0 || i1>rows() || j1>=cols()  ){
#ifdef USE_EXCEPTION
    throw OutOfBound2D(i1,j1,0,rows()-1,0,cols()-1) ;
#else
    Error error("MatrixImage<T>::drawLine") ;
    error << "Error in drawing line\n Invalid index ("<< i1 << ", " << j1 << ") to ( " << i2 << ", " << j2 << ") \n" ;
    error.warning() ;
#endif
    return ;
  }
  if(i2 <0 || j2<0 || i2>rows() || j2>=cols() ){
#ifdef USE_EXCEPTION
    throw OutOfBound2D(i2,j2,0,rows()-1,0,cols()-1) ;
#else
    Error error("MatrixImage<T>::drawLine") ;
    error << "Error in drawing line\n Invalid index ("<< i1 << ", " << j1 << ") to ( " << i2 << ", " << j2 << ") \n" ;
    error.warning() ;
#endif
    return ;
  }

  // check if line is vertical
  if(j1==j2){
    for(i=minimum(i1,i2);i<=maximum(i1,i2);i++)
     operator()(i,j1) = color ;
    return ;
  }
  mx = (double)(i1-i2)/(double)(j1-j2) ;
  b = (double)i1 - mx*j1 ;
  if(absolute(i1-i2)>absolute(j1-j2)){ // draw vertically
    if(i1>i2){
      for(i=i1;i>=i2;i--){
        j = int(((double)i-b)/mx) ;
        operator()(i,j) = color ;
      }
    }
    else{
      for(i=i1;i<=i2;i++){
        j = (int)((i-b)/mx) ;
        operator()(i,j) = color ;
      }
    }
  }
  else{
    if(j1>j2){
      for(j=j1;j>=j2;j--){
        i = (int)(mx*j+b) ;
        operator()(i,j) = color ;
      }
    }
    else{
      for(j=j1;j<=j2;j++){
        i = (int)(mx*j+b) ;
        operator()(i,j) = color ;
      }
    }
  }

}

template <class T>
void MatrixImage<T>::drawPoint(int i, int j, double r , T color){
  for(int y=i-int(ceil(r)) ; y<i+int(ceil(r)) ; y++)
    for(int x = j-int(ceil(r)) ; x<j+int(ceil(r)) ; x++){
      if(y>=0 && y<rows() && x>=0 && x<cols()){
        if( ((y-i)*(y-i)+(x-j)*(x-j))<= r*r)
          operator()(y,x) = color ;
      }
    }
}


template <class T>
void MatrixImage<T>::store(Matrix<T>& a){
  if(a.rows() != rows() || a.cols() != cols()) {
    a.resize(rows(),cols()) ;
  }
  T *aptr, *bptr ;
  int size,i ;
  aptr = &a(0,0)-1 ;
  bptr = m-1 ;
  size = cols()*rows() ;
  for(i=0;i<size;i++)
    *(++aptr) = *(++bptr) ;  
}

#ifdef WITH_IMAGE_MAGICK

template <class T>
IM_ImageT<T>::IM_ImageT(): MatrixImage<T>(){
  autoSave = 0 ;
}

template <class T>
IM_ImageT<T>::IM_ImageT(const std::string &filename, int save): MatrixImage<T>(){
  autoSave = save ;
  //image.read(file_name);
  file_name=filename;
}

template <class T>
IM_ImageT<T>::IM_ImageT(const int r, const int c): MatrixImage<T>(r,c){
  autoSave = 0 ;
}

template <class T>
int IM_ImageT<T>::read(const std::string& filename) {
#ifdef USE_EXCEPTION
  throw MatrixErr() ;
#else
  Error error("IM_ImageT<T>::read") ;
  error << "An image of this type is NOT supported!\n" ;
  error.fatal() ;
#endif
  return 0;
}

template <class T>
int IM_ImageT<T>::write(const std::string& filename) {
#ifdef USE_EXCEPTION
  throw MatrixErr() ;
#else
  Error error("IM_ImageT<T>::write") ;
  error << "An image of this type is NOT supported!\n" ;
  error.fatal() ;
#endif
  return 0 ;
}

template <class T>
void IM_ImageT<T>::setMatrix(){
#ifdef USE_EXCEPTION
  throw MatrixErr() ;
#else
  Error error("IM_ImageT<T>::setImage") ;
  error << "An image of this type is NOT supported!\n" ;
  error.fatal() ;
#endif
}


template <class T>
void IM_ImageT<T>::setImage(){
#ifdef USE_EXCEPTION
  throw MatrixErr() ;
#else
  Error error("IM_ImageT<T>::setImage") ;
  error << "An image of this type is NOT supported!\n" ;
  error.fatal() ;
#endif
}

template <class T>
IM_ImageT<T>::~IM_ImageT(){
  if(autoSave && file_name.length()>0){
    //image.write(file_name) ;
  }
}

#endif


#ifdef NO_IMPLICIT_TEMPLATES
  template class MatrixImage<int> ;
  template class MatrixImage<float> ;
  template class MatrixImage<double> ;
  template class MatrixImage<char> ;
  template class MatrixImage<unsigned char> ;
  template class MatrixImage<Color> ;
#endif


} // end namespace


#endif

---