---

matriximagefactory.h

Go to the documentation of this file.

#ifndef __MATRIX_IMAGE_FACTORY_H__
#define __MATRIX_IMAGE_FACTORY_H__

#include <utility>
#include <string>
using std::string;

// Uses roundabout paths to the current directory to avoid Cray C bug
#include "../src/matriximage.h"
#include "../src/matrixadapter.h"
#include "../src/scale.h"
#include "../src/aarectangle.h"

namespace  Plot {



template<class BaseMatrixType=mat::MatrixInterface<double>,
         class T=typename BaseMatrixType::value_type,
         class ScaleT=Scale::Linear<T>,
         class Rectangle=Boundary::AAArbitraryRectangle<double,int>,
         class PixelType=RGBPixel<>,
         class PixelMatrix=typename MatrixType<PixelType>::rectangular >
class MatrixImageFactory {
  typedef mat::MatrixAdapter<BaseMatrixType> MatrixWindow;

  bool paper_colors;
  double size_scale;
  int border;
  Rectangle box;
  const ColorLookup<PixelType>* strength_clu;
  PixelType bordercolor;
  
public:
  MatrixImageFactory(bool paper_based_colors=false, double size_scale_i=1.0, int border_i=1,
                     Rectangle plot_subregion=Rectangle(),
                     const ColorLookup<PixelType>* strength_colorlookup=0,
                     PixelType bordercolor_=PixelType()) 
    : paper_colors(paper_based_colors), size_scale(size_scale_i), border(border_i),
      box(plot_subregion), strength_clu(strength_colorlookup),
      bordercolor(!bordercolor_.istransparent()? bordercolor_ :
                  MatrixImage<PixelType,PixelMatrix>::default_border) { }

  MatrixImage<PixelType,PixelMatrix>* operator()
    (const BaseMatrixType* const strength=0,   ScaleT strengthscale=ScaleT(),
     const BaseMatrixType* const color=0,      ScaleT colorscale=ScaleT(),
     const BaseMatrixType* const confidence=0, ScaleT confidencescale=ScaleT()) const {

    /* If no strength or color, there is no plot */
    if (!(strength||color))
      return 0;
      
    const typename BaseMatrixType::size_type nrows = (strength? strength->nrows() : color->nrows());
    const typename BaseMatrixType::size_type ncols = (strength? strength->ncols() : color->ncols());

    /* Strength-only plots use the ColorLookup constructor for maximum versatility */
    if (strength && !color) {
      const RYWColorLookup<PixelType> default_clu = RYWColorLookup<PixelType>();
      return new MatrixImage<PixelType,PixelMatrix>
        (MatrixWindow(*strength,strengthscale,box),
         size_scale,border,(strength_clu? *strength_clu : default_clu),bordercolor);
    }


    /* Plots with a specified color dimension use the HSV constructor */
    
    /* Types to be used */
    typedef mat::MatrixInterfaceConstant<T>                              ConstantMatrix;
    typedef Generic::max_fnobj<T>                                        MaxFunType;
    typedef mat::MatrixInterfaceBinaryAdapter<BaseMatrixType,MaxFunType> MaxFunAdapter;
    typedef mat::MatrixInterfaceAdapter<BaseMatrixType>                  MatAdapter;
    
    /* Dummy matrix to stand in for a missing arument */
    const ConstantMatrix   one(1.0,nrows,ncols);
    
    /* Combined matrix needed for paper-based plot with confidence; allows
         color plot to show only where confidence is high. */
    const Scale::Linear<T> negate(-1.0,1.0);
    const MatAdapter       negstrength(*(strength? strength : (confidence? confidence : &one)),negate); // Minor hack
    const MaxFunAdapter    mnp(negstrength,*(confidence? confidence : &one),MaxFunType());
    const BaseMatrixType*  confidencedef = (paper_colors ? &mnp : confidence);
    
    /* Determine appropriate defaults for each matrix */
    const BaseMatrixType& strengthmat   = (strength?   *strength      : one);
    const BaseMatrixType& confidencemat = (confidence? *confidencedef : one);
    
    /* Determine appropriate defaults for each matrix */
    const BaseMatrixType& sat=(paper_colors ? strengthmat   : confidencemat);
    const BaseMatrixType& val=(paper_colors ? confidencemat : strengthmat  );
    
    const ScaleT& satscale=(paper_colors ? strengthscale : confidencescale);
    const ScaleT& valscale=(paper_colors ? confidencescale : strengthscale);
    
    /* Treat as if confidence was 1.0 if there is none */
    return new MatrixImage<PixelType,PixelMatrix>
    (MatrixWindow(*color,colorscale,box),
     MatrixWindow(sat,satscale,box),
     MatrixWindow(val,valscale,box),
     size_scale,border,bordercolor);
  }
};


 
} /* namespace Plot */
#endif /* __MATRIX_IMAGE_FACTORY_H__ */

---