#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

Public Member Functions inherited from G4Surface
	G4Surface ()

virtual	~G4Surface ()

G4int	operator== (const G4Surface &s)

virtual G4String	GetEntityType () const

virtual const char *	Name () const

virtual G4int	MyType () const

void	SetBoundaries (G4CurveVector *)

virtual G4double	HowNear (const G4Vector3D &x) const

virtual G4double	ClosestDistanceToPoint (const G4Point3D &Pt)

G4Vector3D	GetOrigin () const

G4double	GetDistance () const

void	SetDistance (G4double Dist)

G4int	IsActive () const

void	SetActive (G4int act)

void	Deactivate ()

void	SetSameSense (G4int sameSense0)

G4int	GetSameSense () const

G4BoundingBox3D *	GetBBox ()

const G4Point3D &	GetClosestHit () const

void	SetNextNode (G4Surface *)

G4Surface *	GetNextNode ()

virtual void	Reset ()

virtual G4int	Intersect (const G4Ray &)

virtual G4Vector3D	Normal (const G4Vector3D &p) const

virtual void	CalcBBox ()

virtual G4double	GetUHit () const

virtual G4double	GetVHit () const

virtual G4Point3D	Evaluation (const G4Ray &G4Rayref)

virtual G4int	Evaluate (register const G4Ray &Rayref)

virtual void	Project ()

virtual void	CalcNormal ()

virtual G4int	IsConvex () const

virtual G4int	GetConvex () const

virtual G4int	GetNumberOfPoints () const

virtual const G4Point3D &	GetPoint (G4int Count) const

virtual G4Ray *	Norm ()

virtual G4Vector3D	SurfaceNormal (const G4Point3D &Pt) const =0

Public Member Functions inherited from G4STEPEntity
	G4STEPEntity ()

virtual	~G4STEPEntity ()

virtual G4String	GetEntityType () const =0

Protected Attributes
G4SurfaceList *	bezier_list

Protected Attributes inherited from G4Surface
G4BoundingBox3D *	bbox

G4Point3D	closest_hit

G4Surface *	next

G4SurfaceBoundary	surfaceBoundary

G4double	kCarTolerance

G4double	kAngTolerance

G4int	Intersected

G4Vector3D	origin

G4int	Type

G4int	AdvancedFace

G4int	active

G4double	distance

G4double	uhit

G4double	vhit

G4int	sameSense

Static Protected Attributes
static G4int	Clips =0

static G4int	Splits =0

static G4double	Tolerance =0

Friends
class	G4BSplineSurface

class	G4ProjectedSurface

void	CopySurface (G4BezierSurface &bez)

Additional Inherited Members
Static Public Member Functions inherited from G4Surface
static void	Project (G4double &Coord, const G4Point3D &Pt, const G4Plane &Pl)

Protected Member Functions inherited from G4Surface
virtual void	InitBounded ()

Detailed Description

Definition at line 51 of file G4BezierSurface.hh.

Constructor & Destructor Documentation

◆ G4BezierSurface()

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::~G4BezierSurface ( )

virtual

Definition at line 59 of file G4BezierSurface.cc.

{
  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

◆ AveragePoint()

G4Point3D G4BezierSurface::AveragePoint ( ) const

inline

Referenced by G4BSplineSurface::Intersect().

◆ BIntersect()

G4int G4BezierSurface::BIntersect ( G4SurfaceList & bez_list )

Definition at line 211 of file G4BezierSurface.cc.

{
  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;
}

◆ CalcBBox()

void G4BezierSurface::CalcBBox ( )

virtual

Reimplemented from G4Surface.

Definition at line 142 of file G4BezierSurface.cc.

{
  // 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);
}

Referenced by BIntersect().

◆ ChangeDir()

void G4BezierSurface::ChangeDir ( )

inline

◆ ClipBothDirs()

G4int G4BezierSurface::ClipBothDirs ( )

Definition at line 96 of file G4BezierSurface.cc.

{
  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;
}

◆ ClipSurface()

void G4BezierSurface::ClipSurface ( )

Definition at line 301 of file G4BezierSurface.cc.

{
  // 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++; 
}

Referenced by BIntersect(), and ClipBothDirs().

◆ Dir()

void G4BezierSurface::Dir ( G4int d )

inline

◆ GetOrder()

G4int G4BezierSurface::GetOrder ( G4int direction ) const

inline

◆ GetU()

G4double G4BezierSurface::GetU ( ) const

inline

◆ GetV()

G4double G4BezierSurface::GetV ( ) const

inline

◆ PutOrder()

void G4BezierSurface::PutOrder	(	G4int	direction,
		G4int	value
	)

inline

◆ SetAveragePoint()

void G4BezierSurface::SetAveragePoint ( G4Point3D p )

inline

◆ SMax()

G4double G4BezierSurface::SMax ( ) const

inline

◆ SMin()

G4double G4BezierSurface::SMin ( ) const

inline

◆ SurfaceNormal()

G4Vector3D G4BezierSurface::SurfaceNormal ( const G4Point3D & Pt ) const

virtual

Implements G4Surface.

Definition at line 91 of file G4BezierSurface.cc.

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

◆ UAverage()

G4double G4BezierSurface::UAverage ( ) const

inline

◆ VAverage()

G4double G4BezierSurface::VAverage ( ) const

inline

Friends And Related Function Documentation

◆ CopySurface

void CopySurface ( G4BezierSurface & bez )

friend

◆ G4BSplineSurface

friend class G4BSplineSurface

friend

Definition at line 53 of file G4BezierSurface.hh.

◆ G4ProjectedSurface

friend class G4ProjectedSurface

friend

Definition at line 54 of file G4BezierSurface.hh.

Member Data Documentation

◆ bezier_list

G4SurfaceList* G4BezierSurface::bezier_list

protected

Definition at line 93 of file G4BezierSurface.hh.

Referenced by BIntersect(), and ClipBothDirs().

◆ Clips

G4int G4BezierSurface::Clips =0

staticprotected

Definition at line 95 of file G4BezierSurface.hh.

Referenced by ClipSurface().

◆ Splits

G4int G4BezierSurface::Splits =0

staticprotected

Definition at line 96 of file G4BezierSurface.hh.

◆ Tolerance

G4double G4BezierSurface::Tolerance =0

staticprotected

Definition at line 97 of file G4BezierSurface.hh.

Referenced by BIntersect().

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

Public Member Functions

Protected Attributes

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4BezierSurface()

◆ ~G4BezierSurface()

Member Function Documentation

◆ AveragePoint()

◆ BIntersect()

◆ CalcBBox()

◆ ChangeDir()

◆ ClipBothDirs()

◆ ClipSurface()

◆ Dir()

◆ GetOrder()

◆ GetU()

◆ GetV()

◆ PutOrder()

◆ SetAveragePoint()

◆ SMax()

◆ SMin()

◆ SurfaceNormal()

◆ UAverage()

◆ VAverage()

Friends And Related Function Documentation

◆ CopySurface

◆ G4BSplineSurface

◆ G4ProjectedSurface

Member Data Documentation

◆ bezier_list

◆ Clips

◆ Splits

◆ Tolerance