---

matriximage.h

Go to the documentation of this file.

#ifndef __MATRIX_IMAGE_H__
#define __MATRIX_IMAGE_H__

#include <cassert>
#include <algorithm>
#include <cmath>

// Uses roundabout paths to the current directory to avoid Cray C bug
#include "../src/matrix.h"
#include "../src/pixel.h"
#include "../src/colorlookup.h"
#include "../src/boundingbox.h"
#include "../src/image.h"

namespace  Plot {


template<class PixelType=RGBPixel<>, class PixelMatrix= typename MatrixType<PixelType>::rectangular >  
class MatrixImage : public AARImage<PixelType,PixelMatrix> {
private:
  
  typedef typename AARImage<PixelType,PixelMatrix>::PixelSubscript PixelSubscript;
  
  typedef typename AARImage<PixelType,PixelMatrix>::CartesianCoordinate CartesianCoordinate;
  
  typedef int MatrixSubscript;
  
  PixelSubscript border;
  
  MatrixSubscript height;
  
  MatrixSubscript width;
  
  double size_scale;
  
  inline bool inside(const MatrixSubscript r, const MatrixSubscript c) const {
    return (r>=0 && r<height &&
            c>=0 && c<width);
  }
  
  inline MatrixSubscript matrix_row(const MatrixSubscript r) const 
    {  return MatrixSubscript(floor((r-border)/size_scale));  }
  
  inline MatrixSubscript matrix_col(const PixelSubscript c) const 
    {  return MatrixSubscript(floor((c-border)/size_scale));  }
  
  inline PixelSubscript pixel_row(const MatrixSubscript r) const 
    {  return PixelSubscript(r*size_scale)+border;  }
  
  inline PixelSubscript pixel_col(const MatrixSubscript c) const 
    {  return PixelSubscript(c*size_scale)+border;  }
  
  inline CartesianCoordinate x_from_matrixcol(const MatrixSubscript col)
    {  return CartesianCoordinate(pixel_col(col))+size_scale/2;  }
  
  inline CartesianCoordinate y_from_matrixrow(const MatrixSubscript row)
    {  return CartesianCoordinate(nrows()-1-(pixel_row(row)+size_scale/2))+0.5;  }
  
  inline void draw_element(const MatrixSubscript row, const MatrixSubscript col, PixelType p)
    {  draw_rectangle(pixel_row(row), pixel_col(col), pixel_row(row+1), pixel_col(col+1),p);  }
  
  template<class BoundingBoxType> bool onboundary
  (const BoundingBoxType& bb, unsigned thickness, PixelSubscript r, PixelSubscript c) const;
  
  
public:
  
  MatrixImage() : border(0), height(0), width(0), size_scale(1.0)  {  }

  template <class Matrix>
  MatrixImage(const Matrix &A, double scale=1.0, int borderwidth=0,
              const ColorLookup<PixelType>& L=RYWColorLookup<PixelType>(),
              PixelType bordercolor=default_border );
  
  template <class Matrix>
  MatrixImage(const Matrix &H, const Matrix &S, const Matrix &V, double scale=1.0,
              int borderwidth=0, PixelType bordercolor=default_border );
  
  
  // Should length be scaled?
  void draw_bar_on_matrix_element(const MatrixSubscript row, const MatrixSubscript col,
                                  double angle, double length, double width=1, PixelType p=default_fg)
    {  draw_bar(x_from_matrixcol(col), y_from_matrixrow(row), angle, length, width, p);  }
  
  
  template<class BoundingBoxType> inline void outline_boundary
  (const BoundingBoxType& bb, unsigned thickness, PixelType p=default_fg, bool infinite_outline=false);
  
};



template<class PixelType, class PixelMatrix>
template <class Matrix>
MatrixImage<PixelType,PixelMatrix>::MatrixImage
(const Matrix &A, double scale, int borderwidth, const ColorLookup<PixelType>& L,
 PixelType bordercolor)
  : AARImage<PixelType>(typename Matrix::size_type(scale*A.nrows()+2*borderwidth),
                        typename Matrix::size_type(scale*A.ncols()+2*borderwidth)),
  border(borderwidth), height(A.nrows()), width(A.ncols()), size_scale(scale) {
  draw_border(borderwidth,bordercolor);
  typedef typename Matrix::size_type Subscript;
  for   (Subscript r=0; r<A.nrows(); r++)
    for (Subscript c=0; c<A.ncols(); c++) {
      const Bounded::LargeFloat val = mat::elem(A,r,c);
      draw_element(r,c,L(val));
    }
}



template<class PixelType, class PixelMatrix>
template <class Matrix>
MatrixImage<PixelType,PixelMatrix>::MatrixImage
(const Matrix &H, const Matrix &S, const Matrix &V, double scale, int borderwidth,
 PixelType bordercolor)
  : AARImage<PixelType>(typename Matrix::size_type(scale*H.nrows()+2*borderwidth),
                        typename Matrix::size_type(scale*H.ncols()+2*borderwidth)),
  border(borderwidth), height(H.nrows()), width(H.ncols()), size_scale(scale) {
  assert(H.nrows()==S.nrows()); assert(H.nrows()==V.nrows());
  assert(H.ncols()==S.ncols()); assert(H.ncols()==V.ncols());
  draw_border(borderwidth,bordercolor);
  typedef typename Matrix::size_type Subscript;
  for   (Subscript r=0; r<H.nrows(); r++)
    for (Subscript c=0; c<H.ncols(); c++)
      draw_element(r,c,HSVPixel<>(mat::elem(H,r,c),mat::elem(S,r,c),mat::elem(V,r,c)));
}



template<class PixelType, class PixelMatrix>
template<class BoundingBoxType>
void MatrixImage<PixelType,PixelMatrix>::outline_boundary
(const BoundingBoxType& bb, unsigned thickness, PixelType pixel, bool infinite_outline)
{
  PixelType p=pixel;

  const PixelSubscript nr = AARImage<PixelType,PixelMatrix>::nrows();
  const PixelSubscript nc = AARImage<PixelType,PixelMatrix>::ncols();
    
  if (p.istransparent()) {
    PixelAverage<> pa;
    for   (PixelSubscript row=0; row<nr; row++)
      for (PixelSubscript col=0; col<nc; col++)
        if (onboundary(bb,thickness,row,col))
          pa+=get_pixel(row,col);
    p=contrasting_color(pa());
  }

  for   (PixelSubscript row=0; row<nr; row++)
    for (PixelSubscript col=0; col<nc; col++)
      if ((infinite_outline && !bb.inside(matrix_row(row),matrix_col(col))) ||
          (onboundary(bb,thickness,row,col)))
        draw_pixel(row,col,p);
}



template<class PixelType, class PixelMatrix>
template<class BoundingBoxType>
inline bool MatrixImage<PixelType,PixelMatrix>::onboundary
(const BoundingBoxType& bb, unsigned thickness, PixelSubscript r, PixelSubscript c) const
{
  if (inside(matrix_row(r),matrix_col(c)) && bb.inside(matrix_row(r),matrix_col(c)))
    return false;
  
  const PixelSubscript nr = AARImage<PixelType,PixelMatrix>::nrows();
  const PixelSubscript nc = AARImage<PixelType,PixelMatrix>::ncols();

  for   (PixelSubscript sr=max<MatrixSubscript>(0,r-thickness);
         MatrixSubscript(sr)<=min<MatrixSubscript>(nr,r+thickness); sr++)
    for (PixelSubscript sc=max<MatrixSubscript>(0,c-thickness);
         MatrixSubscript(sc)<=min<MatrixSubscript>(nc,c+thickness); sc++) {
      const MatrixSubscript row=matrix_row(sr);
      const MatrixSubscript col=matrix_col(sc);
      if (inside(row,col) && bb.inside(row,col))
        return true;
    }
  
  return false;
}


       
} /* namespace Plot */
#endif /* __MATRIX_IMAGE_H__ */

---