basegfx/source/tools/liangbarsky.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: liangbarsky.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basegfx.hxx"
  33
  34 #include "basegfx/tools/tools.hxx"
  35 #include "basegfx/numeric/ftools.hxx"
  36 #include "basegfx/range/b2drange.hxx"
  37
  38
  39 namespace basegfx
  40 {
  41     namespace tools
  42     {
  43         namespace
  44         {
  45             // see Foley/vanDam, pp. 122 for the Liang-Barsky line
  46             // clipping algorithm
  47             inline bool liangBarskyClipT( double  nDenom,
  48                                           double  nNumerator,
  49                                           double& io_rTE,
  50                                           double& io_rTL )
  51             {
  52                 double t;
  53                 if( nDenom > 0 )
  54                 {
  55                     t = nNumerator / nDenom;
  56                     if( t > io_rTL )
  57                         return false;
  58                     else if( t > io_rTE )
  59                         io_rTE = t;
  60                 }
  61                 else if( nDenom < 0 )
  62                 {
  63                     t = nNumerator / nDenom;
  64                     if( t < io_rTE )
  65                         return false;
  66                     else
  67                         io_rTL = t;
  68                 }
  69                 else if( nNumerator > 0 )
  70                 {
  71                     return false;
  72                 }
  73
  74                 return true;
  75             }
  76         }
  77
  78         // see Foley/vanDam, pp. 122 for the Liang-Barsky line
  79         // clipping algorithm
  80         bool liangBarskyClip2D( ::basegfx::B2DPoint&            io_rStart,
  81                                 ::basegfx::B2DPoint&            io_rEnd,
  82                                 const ::basegfx::B2DRange&      rClipRect )
  83         {
  84             const double nDX( io_rEnd.getX() - io_rStart.getX() );
  85             const double nDY( io_rEnd.getY() - io_rStart.getY() );
  86
  87             if( ::basegfx::fTools::equalZero( nDX ) &&
  88                 ::basegfx::fTools::equalZero( nDY ) )
  89             {
  90                 return rClipRect.isInside( io_rStart );
  91             }
  92             else
  93             {
  94                 double nTE( 0.0 );
  95                 double nTL( 1.0 );
  96                 if( liangBarskyClipT(nDX, rClipRect.getMinX() - io_rStart.getX(),
  97                                      nTE, nTL ) )                                       // inside wrt. left edge
  98                 {
  99                     if( liangBarskyClipT(-nDX, io_rStart.getX() - rClipRect.getMaxX(),
 100                                          nTE, nTL ) )                           // inside wrt. right edge
 101                     {
 102                         if( liangBarskyClipT(nDY, rClipRect.getMinY() - io_rStart.getY(),
 103                                              nTE, nTL ) )                       // inside wrt. bottom edge
 104                         {
 105                             if( liangBarskyClipT(-nDY, io_rStart.getY() - rClipRect.getMaxY(),
 106                                                  nTE, nTL ) )           // inside wrt. top edge
 107                             {
 108                                 // compute actual intersection points,
 109                                 // if nTL has changed
 110                                 if( nTL < 1.0 )
 111                                 {
 112                                     io_rEnd.setX( io_rStart.getX() + nTL*nDX );
 113                                     io_rEnd.setY( io_rStart.getY() + nTL*nDY );
 114                                 }
 115
 116                                 // compute actual intersection points,
 117                                 // if nTE has changed
 118                                 if( nTE > 0.0 )
 119                                 {
 120                                     io_rStart.setX( io_rStart.getX() + nTE*nDX );
 121                                     io_rStart.setY( io_rStart.getY() + nTE*nDY );
 122                                 }
 123
 124                                 // line is (at least partially) visible
 125                                 return true;
 126                             }
 127                         }
 128                     }
 129                 }
 130             }
 131
 132             return false;
 133         }
 134     }
 135 }