SpaceTransform.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
/*
*  This program is free software; you can redistribute it and/or
*  modify it under the terms of the GNU General Public
*  License as published by the Free Software Foundation; either
*  version 2 of the License, or (at your option) any later version.
*
*  This software 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
*  General Public License for more details.
*
*  You should have received a copy of the GNU General Public
*  License along with this software. If not, see
*  <http://www.gnu.org/licenses/>.
*
*/
    
#ifndef _NONA_SPACETRANSFORM_H
#define _NONA_SPACETRANSFORM_H
    
#include <vigra/diff2d.hxx>
#include <hugin_math/Matrix3.h>
 
#include <panodata/PanoramaData.h>
 
 
namespace HuginBase {
namespace Nona {
        
    
struct _FuncParams
{
    union {
        double var0;
        double distance;
        double shift;
    };
    double      var1;
    double      var2;
    double      var3;
    double      var4;
    double      var5;
    double  var6;
    double  var7;
    Matrix3     mt;
};
 
 
typedef void (*trfn)( double x_dest, double y_dest, double* x_src, double* y_src, const _FuncParams &params );
 
 
typedef struct _fDesc
{
    trfn                func;   // function to be called
    _FuncParams param;  // parameters to be used
} fDescription;
 
 
 
class IMPEX SpaceTransform
{
            
    public:
        SpaceTransform();
 
        ~SpaceTransform();
 
        void Init(  const SrcPanoImage & img,
                    const vigra::Diff2D & destSize,
                    PanoramaOptions::ProjectionFormat destProj,
                    double destHFOV );
 
        void InitInv(   const SrcPanoImage & img,
                        const vigra::Diff2D & destSize,
                        PanoramaOptions::ProjectionFormat destProj,
                        double destHFOV );
 
        
        // Different ways to create the transform
        
    public:
        void InitRadialCorrect(const vigra::Size2D & sz, const std::vector<double> & radDist, 
                               const hugin_utils::FDiff2D & centerShift);
 
        void InitRadialCorrect(const SrcPanoImage & src, int channel=1);
 
        void InitInvRadialCorrect(const SrcPanoImage & src, int channel=1);
 
        void createTransform(const SrcPanoImage & src, const PanoramaOptions & dest);
        
        void createInvTransform(const SrcPanoImage & src, const PanoramaOptions & dest);
 
        // create pano -> img transform
        void createTransform(const PanoramaData & pano, unsigned int imgNr,
                             const PanoramaOptions & dest,
                             vigra::Diff2D srcSize=vigra::Diff2D(0,0));
 
        // create image->pano transformation
        void createInvTransform(const PanoramaData & pano, unsigned int imgNr,
                                const PanoramaOptions & dest,
                                vigra::Diff2D srcSize=vigra::Diff2D(0,0));
        
        void createTransform(const vigra::Diff2D & srcSize,
                         const VariableMap & srcVars,
                         Lens::LensProjectionFormat srcProj,
                         const vigra::Diff2D &destSize,
                         PanoramaOptions::ProjectionFormat destProj,
                             double destHFOV);
        
        // create image->pano transformation
        void createInvTransform(const vigra::Diff2D & srcSize,
                                const VariableMap & srcVars,
                                Lens::LensProjectionFormat srcProj,
                                const vigra::Diff2D & destSize,
                                PanoramaOptions::ProjectionFormat destProj,
                                double destHFOV);
        
        
    public:
        bool transform(hugin_utils::FDiff2D& dest, const hugin_utils::FDiff2D & src) const;
 
        bool transformImgCoord(double & x_dest, double & y_dest, double x_src, double y_src) const;
 
        bool transformImgCoord(hugin_utils::FDiff2D & dest, const hugin_utils::FDiff2D &src) const
        {
            return transformImgCoord(dest.x, dest.y, src.x, src.y);
        }
        
        
    public:
        bool isIdentity()
        {
            return m_Stack.empty();
        }
 
        
    private:
        void AddTransform( trfn function_name, double var0, double var1 = 0.0f, double var2 = 0.0f, double var3 = 0.0f, double var4=0.0f, double var5=0.0f, double var6=0.0f, double var7=0.0f );
        void AddTransform( trfn function_name, Matrix3 m, double var0, double var1=0.0f, double var2=0.0f, double var3=0.0f);
        
        
    private:
        bool m_Initialized;
 
        double m_srcTX, m_srcTY;
        double m_destTX, m_destTY;
 
        std::vector<fDescription>       m_Stack;
 
};
 
 
 
 
template <class VECTOR>
void combinePolynom4(const VECTOR & p,
                     const VECTOR & q,
                     VECTOR & c);
 
 
template <class TRANSFORM>
void traceImageOutline(vigra::Size2D sz,
                       TRANSFORM & transf,
                       vigra::Rect2D & inside,
                       vigra::Rect2D & boundingBox);
 
 
IMPEX double estScaleFactorForFullFrame(const SrcPanoImage & src);
 
 
double estRadialScaleCrop(const std::vector<double> & coeff, int width, int height);
 
 
 
 
 
//==============================================================================
// template implementations
 
template <class VECTOR>
void combinePolynom4(const VECTOR & p, const VECTOR & q, VECTOR & c)
{
    double d3 = p[3]*p[3]*p[3];
    c[0] = (3*q[1]*p[3]*p[3]*p[2]+q[3]*p[0]+q[2]*(2*p[3]*p[1]+p[2]*p[2])+q[0]*d3*p[3]);
    c[1] = (2*q[2]*p[3]*p[2]+q[1]*d3+q[3]*p[1]);
    c[2] = (q[3]*p[2]+q[2]*p[3]*p[3]);
    c[3] = q[3]*p[3];
 
    /*
    old code for polynoms of up to x^3
    c[0] = q[0]*(p[2]*(2*p[3]*p[1]+p[2]*p[2])+p[3]*(2*p[3]*p[0]+2*p[2]*p[1])+p[0]*p[3]*p[3]+2*p[1]*p[3]*p[2])
           +q[1]*(2*p[3]*p[0]+2*p[2]*p[1])+q[2]*p[0];
 
    c[1] = q[0]*(p[3]*(2*p[3]*p[1]+p[2]*p[2])+2*p[2]*p[2]*p[3]+p[1]*p[3]*p[3])
            +q[2]*p[1]+q[1]*(2*p[3]*p[1]+p[2]*p[2]);
 
    c[2] = 3*q[0]*p[3]*p[3]*p[2]+2*q[1]*p[3]*p[2]+q[2]*p[2];
    c[3] = q[0]*p[3]*p[3]*p[3]+q[1]*p[3]*p[3]+q[2]*p[3]+q[3];
    */
}
 
 
template <class TRANSFORM>
void traceImageOutline(vigra::Size2D sz, TRANSFORM & transf, vigra::Rect2D & inside, vigra::Rect2D & boundingBox)
{
    boundingBox = vigra::Rect2D();
    inside = vigra::Rect2D();
    int x=0;
    int y=0;
    double xd;
    double yd;
    transf.transformImgCoord(xd,yd, x,y);
    // calculate scaling factor that would be required to avoid black borders
//    double scale = std::max((-sz.x/2)/(xd-sz.x/2), (-sz.y/2)/(yd-sz.y/2));
    int left = 0;
    int right = sz.x;
    int top = 0;
    int bottom = sz.y;
    // left
    for (y=0; y < sz.y; y++) {
        transf.transformImgCoord(xd,yd, x,y);
        boundingBox |= vigra::Point2D(hugin_utils::roundi(xd), hugin_utils::roundi(yd));
        left = std::max(hugin_utils::roundi(xd), left);
    }
    // right
    x = sz.x-1;
    for (y=0; y < sz.y; y++) {
        transf.transformImgCoord(xd,yd, x,y);
        boundingBox |= vigra::Point2D(hugin_utils::roundi(xd), hugin_utils::roundi(yd));
        right = std::min(hugin_utils::roundi(xd), right);
    }
    // bottom
    y=sz.y-1;
    for (x=0; x < sz.x; x++) {
        transf.transformImgCoord(xd,yd, x,y);
        boundingBox |= vigra::Point2D(hugin_utils::roundi(xd), hugin_utils::roundi(yd));
        bottom = std::min(hugin_utils::roundi(yd), bottom);
    }
    // top
    y=0;
    for (x=0; x < sz.x; x++) {
        transf.transformImgCoord(xd,yd, x,y);
        boundingBox |= vigra::Point2D(hugin_utils::roundi(xd), hugin_utils::roundi(yd));
        top = std::max(hugin_utils::roundi(yd), top);
    }
    inside.setUpperLeft(vigra::Point2D(left, top));
    inside.setLowerRight(vigra::Point2D(right, bottom));
}
 
 
 
} // namespace
} // namespace
 
#endif