ClipRect.h

Go to the documentation of this file.

/******************************************************************************
 *
 *  Copyright (C) 2008 Boris Iven, Max Hermann
 *
 *  This file is part of the "CEDRIC Event Display" application.
 *
 *****************************************************************************/

#ifndef CLIPRECT_H
#define CLIPRECT_H

#include <ostream>

#define CLIPRECT_SUPPORT_OSG
#define CLIPRECT_SUPPORT_QT

#ifdef CLIPRECT_SUPPORT_OSG
#include <osg/BoundingBox>
#include <osg/BoundingSphere>
#include <osg/Vec2>
#endif

#ifdef CLIPRECT_SUPPORT_QT
#include <QRect>
#endif

struct ClipRect
{
        ClipRect()
                : left(0),right(0),bottom(0),top(0) 
                {}
        
        ClipRect( double left_, double right_, double bottom_, double top_ )
                : left(left_), right(right_), bottom(bottom_), top(top_)
                {}                      

        double left, right, bottom, top;
        
        void sort()
                {
                        if( left > right ) std::swap( left, right );
                        if( bottom > top ) std::swap( top, bottom );
                }
        
        inline double center_x() const
                {
                        return left + (right-left)*.5;
                }
        
        inline double center_y() const
                {
                        return bottom + (top-bottom)*.5;
                }
        
        inline double width() const
                {
                        return fabs(right-left);
                }
        
        inline double height() const
                {
                        return fabs(bottom-top);
                } 
        
        void scale_x( float s )
                {
                        float l = center_x() - .5*s*(right-left);
                        float r = center_x() + .5*s*(right-left);
                        
                        left  = l;
                        right = r;
                }
        
        void scale_y( float s )
                {
                        float b = center_y() - .5*s*(top-bottom);
                        float t = center_y() + .5*s*(top-bottom);
                        
                        bottom = b;
                        top    = t;
                }
        
        double aspect() const
                {
                        return width()/height();
                }
        
        void translate( double x, double y )
                {
                        float l = (center_x() + x) - .5*(right-left);
                        float r = (center_x() + x) + .5*(right-left);
                        float b = (center_y() + y) - .5*(top-bottom);
                        float t = (center_y() + y) + .5*(top-bottom);
                        
                        top = t;
                        left = l;
                        right = r;
                        bottom = b;
                }
        
#ifdef CLIPRECT_SUPPORT_OSG
        ClipRect( osg::Vec2 min, osg::Vec2 max )
                {
                        top = max.y();
                        left = min.x();
                        right = max.x();
                        bottom = min.y();
                }
                
        ClipRect( const osg::BoundingSphere& bs )
                {
                        fromBoundingSphere( bs );
                }
                
        void fromBoundingSphere( const osg::BoundingSphere& bs )
                {
                        left  = bottom = -bs._radius;
                        right = top    = +bs._radius;
                }       
#endif
                
#ifdef CLIPRECT_SUPPORT_QT
        ClipRect( const QRect& qr )
                 {
                         fromQRect( qr );
                 }
        
        void fromQRect( const QRect& qr )
                 {
                         top = qr.top();
                         left = qr.left();
                         right = qr.right();
                         bottom = qr.bottom();
                 }
#endif
};

std::ostream& operator << ( std::ostream& os, const ClipRect& rect );

#endif