G4BezierSurface Class Reference

#include <G4BezierSurface.hh>

Inheritance diagram for G4BezierSurface:

Public Member Functions
	G4BezierSurface ()
virtual	~G4BezierSurface ()
G4Point3D	AveragePoint () const
void	SetAveragePoint (G4Point3D p)
G4double	UAverage () const
G4double	VAverage () const
void	Dir (G4int d)
void	ChangeDir ()
G4double	SMin () const
G4double	SMax () const
G4int	GetOrder (G4int direction) const
void	PutOrder (G4int direction, G4int value)
G4double	GetU () const
G4double	GetV () const
void	CalcBBox ()
G4int	BIntersect (G4SurfaceList &)
G4int	ClipBothDirs ()
void	ClipSurface ()
virtual G4Vector3D	SurfaceNormal (const G4Point3D &Pt) const
Protected Attributes
G4SurfaceList *	bezier_list
Static Protected Attributes
static G4int	Clips = 0
static G4int	Splits = 0
static G4double	Tolerance = 0
Friends
class	G4BSplineSurface
class	G4ProjectedSurface
void	CopySurface (G4BezierSurface &bez)

---

Detailed Description

Definition at line 51 of file G4BezierSurface.hh.

---

Constructor & Destructor Documentation

G4BezierSurface::G4BezierSurface

(

)

Definition at line 48 of file G4BezierSurface.cc.

  : G4Surface(), bezier_list(0), smin(0.), smax(0.),
    average_u(0.), average_v(0.), dir(0), u_knots(0), v_knots(0),
    ctl_points(0), new_knots(0), ord(0), oslo_m(0), lower(0), upper(0),
    u_min(0.), u_max(0.), v_min(0.), v_max(0.), old_points(0)
{
  order[0]=0; order[1]=0;
  u[0]=0.; u[1]=0.;
  v[0]=0.; v[1]=0.;
}

G4BezierSurface::~G4BezierSurface

(

)

[virtual]

Definition at line 59 of file G4BezierSurface.cc.

References G4Surface::bbox, and G4OsloMatrix::GetNextNode().

{
  delete u_knots;
  delete v_knots;
  delete new_knots;
  delete ctl_points;
  delete old_points;
  
  G4OsloMatrix* temp_oslo = oslo_m;
  
  while(oslo_m != (G4OsloMatrix*)0)
  {
    oslo_m = oslo_m->GetNextNode();
    delete temp_oslo;
    temp_oslo = oslo_m;
  }

  delete oslo_m;
  delete bbox;
}

---

Member Function Documentation

G4Point3D G4BezierSurface::AveragePoint

(

)

const [inline]

Definition at line 38 of file G4BezierSurface.icc.

Referenced by G4BSplineSurface::Intersect().

{
  return average_pt;
}

G4int G4BezierSurface::BIntersect

(

G4SurfaceList &

)

Definition at line 211 of file G4BezierSurface.cc.

References G4Surface::bbox, bezier_list, CalcBBox(), ClipSurface(), G4KnotVector::GetKnot(), G4KnotVector::GetSize(), G4BoundingBox3D::GetTestResult(), and Tolerance.

{
  bezier_list = &bez_list;
  G4int clip_regions = 0; // Used for tolerance/efficiency-testing
  
  do
  {
    // Calc bbox
    CalcBBox();

    // Test bbox
/* L. Broglia
    bbox->Test2dBBox();
*/
    // bbox->Test();

    // Check result
    if(!bbox->GetTestResult())
      return 0;
    
    // The first clipping has already been Done
    // previously so we continue by doing the
    // actual clip.
    
    // Cut out the clipped region of the surface
    GetClippedRegionFromSurface();
    clip_regions++;
    
    // Calculate the knot vectors and control points
    // for the clipped surface
    RefineSurface();    

    // Gets the u- and v-bounds for the clipped surface
    u_min = u_knots->GetKnot(0);        
    u_max = u_knots->GetKnot(u_knots->GetSize() - 1);   
    v_min = v_knots->GetKnot(0);        
    v_max = v_knots->GetKnot(v_knots->GetSize() - 1); 
    
    // Choose the G4Vector3D for the next() clipping so that
    // the larger side will be clipped.  
    if( (u_max - u_min) < (v_max - v_min) )     
      dir = 1;
    else
      dir = 0;

    // Calculate the clip points
    ClipSurface();
    //      G4cout << "\n       SMINMAX : " << smin << "  " << smax; 
    
    // The ray intersects with the bounding box
    // but not with the surface itself.   
    if( smin > 1.0 || smax < 0.0 )
    {
      //            G4cout << "\nG4BezierSurface::Intersect : bezier missed!"; 
      //            bezier_list->RemoveSurface(this);
      return 0;
    }
    
    if( (smax - smin) > 0.8)
    {
      // Multiple intersections
      //            G4cout << "\nG4BezierSurface::Intersect : Bezier split.";
      SplitNURBSurface();
      // Now the two new surfaces should also be
      // clipped in both G4Vector3Ds i.e the
      // last and the second last surface
      // in the List. This is Done after returning
      // from this function.
      //            G4cout << "\n\n  BEZ SPLIT in final Calc! \n\n";

            
      return 2;
    }
    
    // Calculate the smin and smax values on the
    // b_spline.
    LocalizeClipValues();       
    
    // Check if the size of the remaining surface is within the
    // Tolerance .  
  } while ((u_max - u_min > Tolerance) || (v_max - v_min) > Tolerance);    
  
  SetValues();
  //    G4cout << "\nG4BezierSurface::Intersect :Regions were cut " 
  //           << clip_regions << "  Times.\n";
  
  return 1;
}

void G4BezierSurface::CalcBBox

(

)

[virtual]

Reimplemented from G4Surface.

Definition at line 142 of file G4BezierSurface.cc.

References G4Surface::bbox, G4ControlPoints::Get3D(), G4ControlPoints::GetCols(), G4ControlPoints::GetRows(), and PINFINITY().

Referenced by BIntersect().

{
  // Finds the bounds of the 2D-projected nurb iow
  // calculates the bounds for a bounding rectangle
  // to the surface. The bounding rectangle is used
  // for a preliminary check of intersection.
  G4Point3D box_min = G4Point3D(PINFINITY);
  G4Point3D box_max = G4Point3D(-PINFINITY);
 
    
  // Loop to search the whole control point mesh
  // for the minimum and maximum values for.X() and y.
  for(register G4int a = ctl_points->GetRows()-1; a>=0;a--)
    for(register G4int b = ctl_points->GetCols()-1; b>=0;b--)
    {
/* L. Broglia
      G4Point2d& tmp = (G4Point2d&)ctl_points->get(a,b);
      if((box_min.X()) > (tmp.X())) box_min.X(tmp.X());
      if((box_max.X()) < (tmp.X())) box_max.X(tmp.X()); 
      if((box_min.Y()) > (tmp.Y())) box_min.Y(tmp.Y()); 
      if((box_max.Y()) < (tmp.Y())) box_max.Y(tmp.Y()); 
*/
      G4Point3D tmp = ctl_points->Get3D(a,b);
      if((box_min.x()) > (tmp.x())) box_min.setX(tmp.x());
      if((box_max.x()) < (tmp.x())) box_max.setX(tmp.x());      
      if((box_min.y()) > (tmp.y())) box_min.setY(tmp.y());      
      if((box_max.y()) < (tmp.y())) box_max.setY(tmp.y());    
    }
        
  bbox = new G4BoundingBox3D(box_min, box_max);
}

void G4BezierSurface::ChangeDir

(

)

[inline]

Definition at line 68 of file G4BezierSurface.icc.

{
  dir=!dir;
}

G4int G4BezierSurface::ClipBothDirs

(

)

Definition at line 96 of file G4BezierSurface.cc.

References bezier_list, ClipSurface(), COL, G4SurfaceList::RemoveSurface(), and ROW.

{
  dir = ROW;
  ClipSurface(); 
  
  //   G4cout << "\n CLIP BOTH DIRS  1: " << smin << "  " << smax;

  if(smin > 1.0 || smax < 0.0)
  {
    bezier_list->RemoveSurface(this);
    return 1;
  }
  else
    if((smax - smin) > 0.8)
    {
      SplitNURBSurface();
      return 0;
    }
  
  LocalizeClipValues();
  SetValues();
  
  // Other G4Vector3D clipping and testing.
  dir = COL;
  ClipSurface();
  //    G4cout << "\n CLIP BOTH DIRS  2: " << smin << "  " << smax;
    
  if(smin > 1.0 || smax < 0.0)
  {
    bezier_list->RemoveSurface(this);
    return 1;
  }
  else
    if((smax - smin) > 0.8)
    {
      SplitNURBSurface();
      return 0;
    }

  LocalizeClipValues();    
  SetValues();
  CalcAverage();
  return 1;
}

void G4BezierSurface::ClipSurface

(

)

Definition at line 301 of file G4BezierSurface.cc.

References Clips, G4cout, G4ControlPoints::Get3D(), G4ControlPoints::GetCols(), G4ConvexHull::GetMax(), G4ConvexHull::GetMin(), G4ConvexHull::GetNextHull(), G4ConvexHull::GetParam(), G4ControlPoints::GetRows(), G4Surface::kCarTolerance, CLHEP::detail::n, ROW, G4ConvexHull::SetMax(), G4ConvexHull::SetMin(), and G4ConvexHull::SetNextHull().

Referenced by BIntersect(), and ClipBothDirs().

{
  // This routine is described in Computer Graphics, Volume 24, 
  // Number 4, August 1990 under the title Ray Tracing Trimmed
  // Rational Surface Patches.
  

  //    G4cout << "\nBezier clip.";
  
  register G4int i,j;
  register G4int col_size = ctl_points->GetCols();
  register G4int row_size = ctl_points->GetRows();

  G4ConvexHull *ch_tmp= new G4ConvexHull(0,1.0e8,-1.0e8);
  G4ConvexHull *ch_ptr=0, *ch_first=0;
  
  // The four cornerpoints of the controlpoint mesh.

/* L. Broglia
  G4Point2d pt1 = ctl_points->get(0,0);    
  G4Point2d pt2 = ctl_points->get(0,col_size-1);    
  G4Point2d pt3 = ctl_points->get(row_size-1,0);    
  G4Point2d pt4 = ctl_points->get(row_size-1,col_size-1);    
  G4Point2d v1,v2,v3;
*/
  G4Point3D pt1 = ctl_points->Get3D(0,0);    
  G4Point3D pt2 = ctl_points->Get3D(0,col_size-1);    
  G4Point3D pt3 = ctl_points->Get3D(row_size-1,0);    
  G4Point3D pt4 = ctl_points->Get3D(row_size-1,col_size-1);    
  G4Point3D v1,v2,v3;

  if ( dir == ROW)
  {
    // Vectors from cornerpoints
    v1 = (pt1 - pt3);
    //  v1.X() = pt1.X() - pt3.X();
    //  v1.Y() = pt1.Y() - pt3.Y();
    v2 = (pt2 - pt4);
    //  v2.X() = pt2.X() - pt4.X();
    //  v2.Y() = pt2.Y() - pt4.Y();
  } 
  else
  {
    v1 = pt1 - pt2;
    v2 = pt3 - pt4;
    //  v1.X() = pt1.X() - pt2.X();
    //  v1.Y() = pt1.Y() - pt2.Y();
    //  v2.X() = pt3.X() - pt4.X();
    //  v2.Y() = pt3.Y() - pt4.Y();             
  }
/* L. Broglia  
  v3.X(v1.X() + v2.X());
  v3.Y(v1.Y() + v1.Y());
*/
  v3 = v1 + v2 ;
  
  smin =  1.0e8;
  smax = -1.0e8;
  
  G4double norm = std::sqrt(v3.x() * v3.x() + v3.y() * v3.y());
  if(!norm)
  {
    G4cout << "\nNormal zero!";
    G4cout << "\nLINE & DIR: " << line.x() << " " << line.y() << "  " << dir; 
    G4cout << "\n";
    
    if((std::abs(line.x())) > kCarTolerance) 
      line.setX(-line.x());
    else
      if((std::abs(line.y())) > kCarTolerance)
        line.setY(-line.y());
      else
      {
        G4cout << "\n  RETURNING FROm CLIP..";
        smin = 0; smax = 1; delete ch_tmp;
        return;
      }

    G4cout << "\nCHANGED LINE & DIR: " << line.x() << " " 
           << line.y() << "  " << dir;          
  }
  else
  {
    line.setX( v3.y() / norm);
    line.setY(-v3.x() / norm);
  }

  //    smin =  1.0e8;
  //    smax = -1.0e8;
  //    G4cout << "\n  FINAL LINE & DIR: " << line.X() << " " 
  //           << line.Y() << "  " << dir;      
  
  if( dir == ROW)
  {
    // Create a Convex() hull List 
    for(G4int a = 0; a < col_size; a++)
    {
      ch_ptr = new G4ConvexHull(a/(col_size - 1.0),1.0e8,-1.0e8);
      if(! a) 
      {
        ch_first=ch_ptr; delete ch_tmp;
      }
      else ch_tmp->SetNextHull(ch_ptr);
      
      ch_tmp=ch_ptr;
    }
    
    ch_ptr=ch_first;
    register G4double value;
    
    // Loops through the control point mesh and calculates
    // the nvex() hull for the surface.
    
    for( G4int h = 0; h < row_size; h++)
    {
      for(G4int k = 0; k < col_size; k++)
      {
/* L. Broglia
        G4Point2d& coordstmp = (G4Point2d&)ctl_points->get(h,k);  
        value = - ((coordstmp.X() * line.X() + coordstmp.Y() * line.Y()));
*/
        G4Point3D coordstmp = ctl_points->Get3D(h,k);  
        value = - ((coordstmp.x() * line.x() + coordstmp.y() * line.y()));

        if( value <= (ch_ptr->GetMin()+kCarTolerance)) ch_ptr->SetMin(value);
        if( value >= (ch_ptr->GetMax()-kCarTolerance)) ch_ptr->SetMax(value);
            
        ch_ptr=ch_ptr->GetNextHull();
      }
      
      ch_ptr=ch_first;
    }
    
    ch_ptr=ch_first;
    // Finds the points where the nvex() hull intersects
    // with the coordinate .X()is. These points are the
    // minimum and maximum values to where to clip the
    // surface.
    
    for(G4int l = 0; l < col_size - 1; l++)
    {
      ch_tmp=ch_ptr->GetNextHull();
      for(G4int q = l+1; q < col_size; q++)
      {
        register G4double d, param1, param2;
        param1 = ch_ptr->GetParam();
        param2 = ch_tmp->GetParam();
        
        if(ch_tmp->GetMax() - ch_ptr->GetMax())
        {
          d = Findzero( param1, param2, ch_ptr->GetMax(), ch_tmp->GetMax());
          if( d <= (smin + kCarTolerance) ) smin = d * .99;
          if( d >= (smax - kCarTolerance) ) smax = d * .99 + .01;
        }
        
        if(ch_tmp->GetMin() - ch_ptr->GetMin())
        {
          d = Findzero( param1, param2, ch_ptr->GetMin(), ch_tmp->GetMin());
          if( d <= (smin + kCarTolerance)) smin = d * .99;
          if( d >= (smax - kCarTolerance)) smax = d * .99 + .01;
        }
        
        ch_tmp=ch_tmp->GetNextHull();
      }
      
      ch_ptr=ch_ptr->GetNextHull();
    }
    
    ch_ptr=ch_first;

    if (smin <= 0.0)   smin = 0.0;
    if (smax >= 1.0)   smax = 1.0;

    if ( (ch_ptr)
      && (Sign(ch_ptr->GetMin()) != Sign(ch_ptr->GetMax())))  smin = 0.0;
    
    i = Sign(ch_tmp->GetMin()); // ch_tmp points to last nvex()_hull in List
    j = Sign(ch_tmp->GetMax());
    
    if ( std::abs(i-j) > kCarTolerance ) smax = 1.0;
    //  if ( i != j)  smax = 1.0;
    
  } 
  else // Other G4Vector3D
  {
    for(G4int n = 0; n < row_size; n++)
      {
        ch_ptr = new G4ConvexHull(n/(row_size - 1.0),1.0e8,-1.0e8);
        if(!n) 
        {
          ch_first=ch_ptr; delete ch_tmp;
        }
        else ch_tmp->SetNextHull(ch_ptr);
        
        ch_tmp=ch_ptr;
      }
    
    ch_ptr=ch_first;
    
    for( G4int o = 0; o < col_size; o++)
    {
      for(G4int p = 0; p < row_size; p++)
      {
        register G4double value;

/* L. Broglia
        G4Point2d& coordstmp =(G4Point2d&) ctl_points->get(p,o);              
        value = - ((coordstmp.X() * line.X() + coordstmp.Y() * line.Y()));
*/
        G4Point3D coordstmp = ctl_points->Get3D(p,o);         
        value = - ((coordstmp.x() * line.x() + coordstmp.y() * line.y()));

        if( value <= (ch_ptr->GetMin()+kCarTolerance)) ch_ptr->SetMin(value);
        if( value >= (ch_ptr->GetMax()-kCarTolerance)) ch_ptr->SetMax(value);
        
        ch_ptr=ch_ptr->GetNextHull();
      }

      ch_ptr=ch_first;
    }
    
    ch_ptr=ch_first;
    delete ch_tmp;
    
    for(G4int q = 0; q < row_size - 1; q++)
    {
      ch_tmp=ch_ptr->GetNextHull();
      for(G4int r = q+1; r < row_size; r++)
      {
        register G4double param1 = ch_ptr->GetParam();
        register G4double param2 = ch_tmp->GetParam();
        register G4double d;
        
        if(ch_tmp->GetMax() - ch_ptr->GetMax())
        {
          d = Findzero( param1, param2, ch_ptr->GetMax(), ch_tmp->GetMax());
          if( d <= (smin + kCarTolerance) ) smin = d * .99;
          if( d >= (smax - kCarTolerance) ) smax = d * .99 + .01;
        }

        if(ch_tmp->GetMin()-ch_ptr->GetMin())
        {
          d = Findzero( param1, param2, ch_ptr->GetMin(), ch_tmp->GetMin());
          if( d <= (smin + kCarTolerance) ) smin = d * .99;
          if( d >= (smax - kCarTolerance) ) smax = d * .99 + .01;
        }
        
        ch_tmp=ch_tmp->GetNextHull();
      }

      ch_ptr=ch_ptr->GetNextHull();
    }
    
    ch_tmp=ch_ptr;
    ch_ptr=ch_first;
        
    if (smin <= 0.0)  smin = 0.0;
    if (smax >= 1.0)  smax = 1.0;
    
    if ( (ch_ptr)
      && (Sign(ch_ptr->GetMin()) != Sign(ch_ptr->GetMax()))) smin = 0.0;

    if ( ch_tmp )
    {
      i = Sign(ch_tmp->GetMin()); // ch_tmp points to last nvex()_hull in List
      j = Sign(ch_tmp->GetMax());
      if ( (std::abs(i-j) > kCarTolerance)) smax = 1.0;
    }
  }

  ch_ptr=ch_first;
  while(ch_ptr && (ch_ptr!=ch_ptr->GetNextHull()))
  {
    ch_tmp=ch_ptr;
    ch_ptr=ch_ptr->GetNextHull();
    delete ch_tmp;
  }

  delete ch_ptr;
  
  // Testing...    
  Clips++; 
}

void G4BezierSurface::Dir

(

G4int

d

)

[inline]

Definition at line 62 of file G4BezierSurface.icc.

{
  dir=d;
}

G4int G4BezierSurface::GetOrder

(

G4int

direction

)

const [inline]

Definition at line 86 of file G4BezierSurface.icc.

{
  return order[direction];
}

G4double G4BezierSurface::GetU

(

)

const [inline]

Definition at line 98 of file G4BezierSurface.icc.

{
  return (u_min + u_max)/2.0;
}

G4double G4BezierSurface::GetV

(

)

const [inline]

Definition at line 104 of file G4BezierSurface.icc.

{
  return (v_min + v_max)/2.0;
}

void G4BezierSurface::PutOrder	(	G4int	direction,
		G4int	value
	)			[inline]

Definition at line 92 of file G4BezierSurface.icc.

{
  order[direction]=value;
}

void G4BezierSurface::SetAveragePoint

(

G4Point3D

p

)

[inline]

Definition at line 44 of file G4BezierSurface.icc.

{
  average_pt=p;
}

G4double G4BezierSurface::SMax

(

)

const [inline]

Definition at line 80 of file G4BezierSurface.icc.

{
  return smax;
}

G4double G4BezierSurface::SMin

(

)

const [inline]

Definition at line 74 of file G4BezierSurface.icc.

{
  return smin;
}

G4Vector3D G4BezierSurface::SurfaceNormal

(

const G4Point3D &

Pt

)

const [virtual]

Implements G4Surface.

Definition at line 91 of file G4BezierSurface.cc.

{
  return G4Vector3D(0,0,0);
}

G4double G4BezierSurface::UAverage

(

)

const [inline]

Definition at line 50 of file G4BezierSurface.icc.

{
  return average_u;
}

G4double G4BezierSurface::VAverage

(

)

const [inline]

Definition at line 56 of file G4BezierSurface.icc.

{
  return average_v;
}

---

Friends And Related Function Documentation

void CopySurface

(

G4BezierSurface &

bez

)

[friend]

friend class G4BSplineSurface [friend]

Definition at line 53 of file G4BezierSurface.hh.

friend class G4ProjectedSurface [friend]

Definition at line 54 of file G4BezierSurface.hh.

---

Field Documentation

G4SurfaceList* G4BezierSurface::bezier_list [protected]

Definition at line 93 of file G4BezierSurface.hh.

Referenced by BIntersect(), and ClipBothDirs().

G4int G4BezierSurface::Clips = 0 [static, protected]

Definition at line 95 of file G4BezierSurface.hh.

Referenced by ClipSurface().

G4int G4BezierSurface::Splits = 0 [static, protected]

Definition at line 96 of file G4BezierSurface.hh.

G4double G4BezierSurface::Tolerance = 0 [static, protected]

Definition at line 97 of file G4BezierSurface.hh.

Referenced by BIntersect().

---

The documentation for this class was generated from the following files:

• G4BezierSurface.hh
• G4BezierSurface.icc
• G4BezierSurface.cc

---