WCResampleHandler.h

Go to the documentation of this file.

//# WCResampleHandler.h: base class for resampling data pixels to the screen
//# Copyright (C) 1993,1994,1995,1996,1998,1999,2000
//# Associated Universities, Inc. Washington DC, USA.
//#
//# 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 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id$

#ifndef TRIALDISPLAY_WCRESAMPLEHANDLER_H
#define TRIALDISPLAY_WCRESAMPLEHANDLER_H

#include <casa/aips.h>
#include <casa/Arrays/Vector.h>

namespace casa { //# NAMESPACE CASA - BEGIN

        template <class T> class Matrix;

// <summary>
// Base class for resampling data pixels to World/PixelCanvas pixels.
// </summary>
//
// <prerequisite>
// <li> Display library image drawing process
// </prerequisite>
//
// <etymology>
// The name of WCResampleHandler comes from
// WorldCanvas + Resample + Handler
// </etymology>
//
// <synopsis>
// WCResampleHandler is the tool used to extract a rectangular
// subregion of an image for purposes of display.  This class is
// abstract and defines the interface the
// <linkto class="WorldCanvas">WorldCanvas</linkto> sees.
//
// When the resample handler fires, it extracts a rectangular subregion
// of its input matrix and stores it in its output matrix.  If
// the default subregion is the whole image and the output image is
// the same size as the input image, then the output image is
// a copy of the input image.
//
// If not, the subregion of the image is resampled to fit the output
// matrix size.
// </synopsis>
//
// <motivation>
// Objectify the concept of resampling to allow programmers
// to write their own, more complicated versions and register
// them with the WorldCanvas.
// </motivation>

        class WCResampleHandler {

        public:

                // (Required) default constructor.
                WCResampleHandler();

                // Copy Constructor (copy semantics)
                WCResampleHandler (const WCResampleHandler& other);

                // Assignment operator (copy semantics)
                WCResampleHandler& operator=(const WCResampleHandler& other);

                // Destructor.
                virtual ~WCResampleHandler();


                // The output array is presized by the caller to the correct size.  It will
                // be filled using information in the input array combined with other
                // resample-specific information.  Here again the interface is type expanded
                // rather than templated because C++ doesn't yet handle templated member
                // functions in a non-templated class.
                // <group>
                virtual void operator()(Matrix<Bool> &out, const Matrix<Bool> &in) = 0;
                virtual void operator()(Matrix<uChar> &out, const Matrix<uChar> &in) = 0;
                virtual void operator()(Matrix<Char> &out, const Matrix<Char> &in) = 0;
                virtual void operator()(Matrix<uShort> &out, const Matrix<uShort> &in) = 0;
                virtual void operator()(Matrix<Short> &out, const Matrix<Short> &in) = 0;
                virtual void operator()(Matrix<uInt> &out, const Matrix<uInt> &in) = 0;
                virtual void operator()(Matrix<Int> &out, const Matrix<Int> &in) = 0;
                virtual void operator()(Matrix<uLong> &out, const Matrix<uLong> &in) = 0;
                virtual void operator()(Matrix<Long> &out, const Matrix<Long> &in) = 0;
                virtual void operator()(Matrix<Float> &out, const Matrix<Float> &in) = 0;
                virtual void operator()(Matrix<Double> &out, const Matrix<Double> &in) = 0;
                virtual void operator()(Matrix<Complex> &out, const Matrix<Complex> &in) = 0;
                virtual void operator()(Matrix<DComplex> &out, const Matrix<DComplex> &in) = 0;
                // </group>

                // These functions resample the input matrix to the output.
                // inblc is the location 'within' the input matrix for the
                // bottom-left pixel of the output (sim. for intrc); blank is
                // the output value where none of the input data is useful.
                // The output matrix must be presized to the required size.
                // <group>
                virtual void operator()(Matrix<Float> &out, const Matrix<Float> &in,
                                        const Vector<Float> &inblc,
                                        const Vector<Float> &intrc,
                                        const Float blank = 0.0) = 0;
                virtual void operator()(Matrix<Float> &out, Matrix<Bool>& outMask,
                                        const Matrix<Float> &in, const Matrix<Bool> &inMask,
                                        const Vector<Float> &inblc,
                                        const Vector<Float> &intrc,
                                        const Float blank = 0.0) = 0;
                virtual void operator()(Matrix<Bool> &out, const Matrix<Bool> &in,
                                        const Vector<Float> &inblc,
                                        const Vector<Float> &intrc,
                                        const Bool blank = False) = 0;
                // </group>

                // These functions manipulate which subregion in "in" gets expanded
                // to "out" Coordinates are the fraction of the image to use, with
                // <0.0, 0.0> representing the bottom-left corner of the first pixel
                // and <1.0, 1.0> representing the top-right corner of the last
                // pixel.  These parameters are interpreted according to the derived
                // class.
                // <group>
                void setSubregion(const Vector<Double> &blc,
                                  const Vector<Double> &trc) {
                        itsBlc = blc;
                        itsTrc = trc;
                }
                void getSubregion(Vector<Double> &blc,
                                  Vector<Double> &trc) const {
                        blc = itsBlc;
                        trc = itsTrc;
                }
                // </group>


        protected:

                // Get the bottom left corner (range <0-1,0-1>) of the subregion
                const Vector<Double> &blc() const {
                        return itsBlc;
                }

                // Get the top right corner (range <0-1,0-1>) of the subregion
                const Vector<Double> &trc() const {
                        return itsTrc;
                }

        private:

                // Current subregion
                Vector<Double> itsBlc;
                Vector<Double> itsTrc;

        };


} //# NAMESPACE CASA - END

#endif