uiworld2ui.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H. Bril
 Date:          13/8/2000
 RCS:           $Id$
________________________________________________________________________
 
-*/
#include "uitoolsmod.h"
#include "uigeom.h"
 
class SurveyInfo;
 
mExpClass(uiTools) World2UiData
{
public:
 
                World2UiData();
                World2UiData( uiSize s, const uiWorldRect& w );
                World2UiData( const uiWorldRect& w, uiSize s );
 
    bool        operator ==( const World2UiData& w2ud ) const;
    bool        operator !=( const World2UiData& w2ud ) const;
 
    uiSize      sz;
    uiWorldRect wr;
};
 
 
mExpClass(uiTools) uiWorld2Ui
{
public:
                        uiWorld2Ui();
                        uiWorld2Ui( const uiSize& sz, const uiWorldRect& wr );
                        uiWorld2Ui( const uiRect& rc, const uiWorldRect& wr );
                        uiWorld2Ui( const uiWorldRect& wr, const uiSize& sz );
                        uiWorld2Ui( const World2UiData& w );
 
    bool                operator==(const uiWorld2Ui& ) const;
 
    void                set( const World2UiData& w );
    void                set( const uiWorldRect& wr, const uiSize& sz );
    void                set( const uiSize& sz, const uiWorldRect& wr );
    void                set( const uiRect& rc, const uiWorldRect& wr );
    void                set( uiRect rc, const SurveyInfo& si );
 
    void                setRemap( const uiSize& sz, const uiWorldRect& wrdrc );
    void                setRemap( const uiRect& rc, const uiWorldRect& wrdrc );
    void                setCartesianRemap( const uiSize& sz,
                            float minx, float maxx, float miny, float maxy );
    void                setCartesianRemap( const uiRect& rc,
                            float minx, float maxx, float miny, float maxy );
 
    void                resetUiRect( const uiRect& rc );
 
    const World2UiData& world2UiData() const;
 
 
    uiWorldPoint        transform( uiPoint p ) const;
    uiWorldRect         transform( uiRect area ) const;
    uiPoint             transform( uiWorldPoint p ) const;
    uiRect              transform( uiWorldRect area ) const;
                        // Since the compiler will be confused if two functions
                        // only differ in return type, Geom::Point2D<float> is
                        // set rather than be returned.
    void                transform(const uiPoint& upt,
                                  Geom::Point2D<float>& pt) const;
    void                transform(const Geom::Point2D<float>& pt,
                                  uiPoint& upt) const;
 
    int                 toUiX(float wrdx) const;
    int                 toUiY(float wrdy) const;
    float               toWorldX(int uix) const;
    float               toWorldY(int uiy) const;
 
    template <class TT,class FT>
    TT                  transformX(FT x,bool toworld) const;
    template <class TT,class FT>
    TT                  transformY(FT y,bool toworld) const;
    template <class TT,class FT>
    Geom::Point2D<TT>   transform(const Geom::Point2D<FT>&,bool toworld) const;
 
    uiWorldPoint        origin() const;
    uiWorldPoint        worldPerPixel() const;
 
    void                getWorldXRange( float& xmin, float& xmax ) const;
    void                getWorldYRange( float& ymin, float& ymax ) const;
 
protected:
 
    World2UiData        w2ud;
 
    uiWorldPoint        p0;
    uiWorldPoint        fac;
 
    uiWorldRect         wrdrect_; 
    uiSize              uisize_;
    uiPoint             uiorigin;
 
private:
                        void getAppropriateRange( float min, float max,
                                                 float& newmin, float& newmax );
};
 
 
template <class TT,class FT>
TT uiWorld2Ui::transformX( FT x, bool toworld ) const
{
    if ( toworld )
        return p0.x + (x-uiorigin.x)*fac.x;
    else
        return (x-p0.x)/fac.x + uiorigin.x;
}
 
template <class TT,class FT>
TT uiWorld2Ui::transformY( FT y, bool toworld ) const
{
    if ( toworld )
        return p0.y + (y-uiorigin.y)*fac.y;
    else
        return (y-p0.y)/fac.y + uiorigin.y;
}
 
 
template <class TT,class FT>
Geom::Point2D<TT> uiWorld2Ui::transform( const Geom::Point2D<FT>& ptin,
                                         bool toworld ) const
{
    return Geom::Point2D<TT>( transformX<TT,FT>(ptin.x,toworld),
                              transformY<TT,FT>(ptin.y,toworld) );
}