Gordon Surface Construction in OCCT

[dpasukhi]

Available in OCCT 8.0.0-rc5

commit: 1cc42af

Introduction

OCCT 8.0.0-rc5 introduces a complete implementation of the Gordon surface algorithm via two new classes: GeomFill_Gordon (high-level) and GeomFill_GordonBuilder (low-level kernel). A Gordon surface interpolates a network of intersecting curves — profiles and guides — producing a smooth B-spline surface that passes exactly through all input curves.

This is particularly useful in CAD/CAM workflows where a designer defines a shape by cross-sections (profiles) and longitudinal curves (guides), such as ship hulls, aircraft fuselages, car body panels, and turbine blades.

Mathematical Background

The Gordon surface is constructed using the Boolean sum formula:

S(u, v) = S_profiles(u, v) + S_guides(u, v) - S_tensor(u, v)

Where:

• S_profiles — surface skinned through profile curves (lofting in the V direction)
• S_guides — surface skinned through guide curves (lofting in the U direction)
• S_tensor — tensor product surface through the intersection points (correction term)

The subtraction of the tensor product surface corrects for the double-counting at intersection points, ensuring the final surface passes through all input curves exactly.

API Overview

High-Level: GeomFill_Gordon

The recommended entry point. Accepts arbitrary Geom_Curve inputs (lines, B-splines, trimmed curves, etc.), handles conversion, intersection detection, sorting, and reparametrization automatically.

#include <GeomFill_Gordon.hxx>

// Prepare profile curves (cross-sections, >= 2)
NCollection_Array1<occ::handle<Geom_Curve>> aProfiles(1, 3);
aProfiles(1) = /* ... */;
aProfiles(2) = /* ... */;
aProfiles(3) = /* ... */;

// Prepare guide curves (longitudinal, >= 2)
NCollection_Array1<occ::handle<Geom_Curve>> aGuides(1, 2);
aGuides(1) = /* ... */;
aGuides(2) = /* ... */;

// Build the Gordon surface
GeomFill_Gordon aGordon;
aGordon.Init(aProfiles, aGuides, Precision::Confusion());
aGordon.Perform();

if (aGordon.IsDone())
{
  const occ::handle<Geom_BSplineSurface>& aSurface = aGordon.Surface();
  // Use the surface...
}

Key features:

• Accepts any Geom_Curve subtype (lines, B-splines, trimmed curves)
• Automatic curve network sorting and orientation
• Automatic intersection detection
• Reparametrization for compatibility
• Optional parallel mode: aGordon.SetParallelMode(true)

Low-Level: GeomFill_GordonBuilder

For advanced users who already have compatible B-spline curves with known intersection parameters.

#include <GeomFill_GordonBuilder.hxx>

// Pre-compatible BSpline curves (same degree & knot vectors within each group)
NCollection_Array1<occ::handle<Geom_BSplineCurve>> aProfiles(1, N);
NCollection_Array1<occ::handle<Geom_BSplineCurve>> aGuides(1, M);
NCollection_Array1<double> aProfileParams(1, N);  // V-parameters of profiles
NCollection_Array1<double> aGuideParams(1, M);    // U-parameters of guides

GeomFill_GordonBuilder aBuilder;
aBuilder.Init(aProfiles, aGuides, aProfileParams, aGuideParams, Precision::Confusion());
aBuilder.Perform();

if (aBuilder.IsDone())
{
  const occ::handle<Geom_BSplineSurface>& aSurface       = aBuilder.Surface();
  const occ::handle<Geom_BSplineSurface>& aProfileSurf   = aBuilder.ProfileSurface();
  const occ::handle<Geom_BSplineSurface>& aGuideSurf     = aBuilder.GuideSurface();
  const occ::handle<Geom_BSplineSurface>& aTensorSurf    = aBuilder.TensorSurface();
}

Additional features over the high-level API:

• Access to intermediate surfaces (profile, guide, tensor)
• Support for closed/periodic curve networks (theIsUClosed, theIsVClosed)
• Fine-grained control over parametrization

Demonstration Gallery

Six demonstration cases showcase the algorithm on diverse curve networks. Each produces both the input wireframe (*_basis.brep) and the resulting surface (*_surface.brep).

1. Barrel Vault

Arch-shaped profiles with height varying along span. The tallest arch is at mid-span, creating a tunnel/vault shape.

Z(x, y) = (0.4 + 0.2 * sin(pi*y)) * sin(pi*x)

5 profiles + 5 guides.

2. Saddle

Classic saddle point: profiles arch upward, guides arch downward. The center is a saddle point where curvatures have opposite signs.

Z(x, y) = 0.5 * sin(pi*x) - 0.5 * sin(pi*y)

3 profiles + 3 guides.

3. Gaussian Peak

A bell-shaped dome with smooth Gaussian falloff in all directions. Both profiles and guides are bell curves with varying amplitudes.

Z(x, y) = 0.8 * exp(-8 * ((x-0.5)^2 + (y-0.5)^2))

5 profiles + 5 guides.

4. Traveling Wave

A cosine wave propagating diagonally across the surface. Profiles are phase-shifted cosines; guides are smooth arches alternating direction.

Z(x, y) = 0.25 * cos(2*pi*x - pi*y)

5 profiles + 5 guides.

5. Helicoid

A twisted helical surface built from true 3D space curves. Profiles are tilted radial lines at different angles; guides are helical arcs. This demonstrates the algorithm on genuinely non-planar curve networks.

S(u, v) = { v*cos(u),  v*sin(u),  0.3*u }

4 profiles (radial lines) + 4 guides (helical arcs).

6. Monkey Saddle

A surface with 3-fold symmetry: three alternating hills and valleys meet at the center. Each profile and guide has a distinct S-shaped or M-shaped cubic curve.

Z(x, y) = 4 * ((x-0.5)^3 - 3*(x-0.5)*(y-0.5)^2)

5 profiles + 5 guides.

Complete Example: Custom Curve Network

Here is a self-contained example building a Gordon surface from a Z(x,y) function:

#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRepTools.hxx>
#include <BRep_Builder.hxx>
#include <Geom_BSplineCurve.hxx>
#include <GeomAPI_Interpolate.hxx>
#include <GeomFill_Gordon.hxx>
#include <NCollection_Array1.hxx>
#include <NCollection_HArray1.hxx>
#include <Precision.hxx>
#include <TopoDS_Compound.hxx>

// Step 1: Define an interpolation helper
occ::handle<Geom_BSplineCurve> InterpolatePoints(
  const NCollection_Array1<gp_Pnt>& thePts)
{
  const int aNb = thePts.Length();
  occ::handle<NCollection_HArray1<gp_Pnt>> aPnts =
    new NCollection_HArray1<gp_Pnt>(1, aNb);
  occ::handle<NCollection_HArray1<double>> aParams =
    new NCollection_HArray1<double>(1, aNb);
  for (int i = 0; i < aNb; ++i)
  {
    aPnts->SetValue(i + 1, thePts(thePts.Lower() + i));
    aParams->SetValue(i + 1, static_cast<double>(i) / (aNb - 1));
  }
  GeomAPI_Interpolate anInterp(aPnts, aParams, false, Precision::Confusion());
  anInterp.Perform();
  return anInterp.Curve();
}

// Step 2: Define your Z(x,y) surface function
double MyZFunction(double theX, double theY)
{
  // Example: a Gaussian dome
  double aDx = theX - 0.5, aDy = theY - 0.5;
  return 0.8 * std::exp(-8.0 * (aDx * aDx + aDy * aDy));
}

// Step 3: Build the curve network
void BuildGordonSurface()
{
  constexpr int THE_NB_PTS = 21;

  // Create profiles at Y = 0.0, 0.25, 0.5, 0.75, 1.0
  double aProfY[] = {0.0, 0.25, 0.5, 0.75, 1.0};
  NCollection_Array1<occ::handle<Geom_Curve>> aProfiles(1, 5);
  for (int i = 0; i < 5; ++i)
  {
    NCollection_Array1<gp_Pnt> aPts(1, THE_NB_PTS);
    for (int k = 1; k <= THE_NB_PTS; ++k)
    {
      double aX = static_cast<double>(k - 1) / (THE_NB_PTS - 1);
      aPts(k) = gp_Pnt(aX, aProfY[i], MyZFunction(aX, aProfY[i]));
    }
    aProfiles(i + 1) = InterpolatePoints(aPts);
  }

  // Create guides at X = 0.0, 0.25, 0.5, 0.75, 1.0
  double aGuidX[] = {0.0, 0.25, 0.5, 0.75, 1.0};
  NCollection_Array1<occ::handle<Geom_Curve>> aGuides(1, 5);
  for (int j = 0; j < 5; ++j)
  {
    NCollection_Array1<gp_Pnt> aPts(1, THE_NB_PTS);
    for (int k = 1; k <= THE_NB_PTS; ++k)
    {
      double aY = static_cast<double>(k - 1) / (THE_NB_PTS - 1);
      aPts(k) = gp_Pnt(aGuidX[j], aY, MyZFunction(aGuidX[j], aY));
    }
    aGuides(j + 1) = InterpolatePoints(aPts);
  }

  // Step 4: Construct the Gordon surface
  GeomFill_Gordon aGordon;
  aGordon.Init(aProfiles, aGuides, 0.01);
  aGordon.Perform();

  if (!aGordon.IsDone())
  {
    std::cerr << "Gordon surface construction failed.\n";
    return;
  }

  const occ::handle<Geom_BSplineSurface>& aSurface = aGordon.Surface();

  // Step 5: Save input curves as BRep
  BRep_Builder aBld;
  TopoDS_Compound aBasis;
  aBld.MakeCompound(aBasis);
  for (int i = aProfiles.Lower(); i <= aProfiles.Upper(); ++i)
  {
    BRepBuilderAPI_MakeEdge aME(aProfiles(i));
    if (aME.IsDone()) aBld.Add(aBasis, aME.Edge());
  }
  for (int j = aGuides.Lower(); j <= aGuides.Upper(); ++j)
  {
    BRepBuilderAPI_MakeEdge aME(aGuides(j));
    if (aME.IsDone()) aBld.Add(aBasis, aME.Edge());
  }
  BRepTools::Write(aBasis, "my_gordon_basis.brep");

  // Step 6: Save resulting surface as BRep face
  BRepBuilderAPI_MakeFace aMF(aSurface, Precision::Confusion());
  if (aMF.IsDone())
  {
    BRepTools::Write(aMF.Face(), "my_gordon_surface.brep");
  }
}

Requirements and Limitations

• Minimum curves: At least 2 profiles and 2 guides
• Curve types: Non-rational curves only (rational B-splines are not supported)
• Intersection consistency: Each profile must intersect each guide at exactly one point
• Toolkit dependency: TKGeomAlgo (include GeomFill_Gordon.hxx)

Demo:
GordonDemo.zip

Best regards,
OCCT3D Team.