Specific Direction Curvature

Here's some python(occ) code that might help you.
Notice the "_setup_trimmed" method for testing if a sample is not taken at a trimmed part of the surface.

-jelle

from OCC.TopoDS import *
from OCC.BRep import *
from OCC.BRepTools import *
from OCC.BRepTopAdaptor import *
from OCC.GeomLProp import *
from OCC.gp import *
from OCC.TopAbs import *

import numpy, math
from scipy.ndimage import spline_filter, map_coordinates

class SampleSurface(object):
def __init__(self, srf, resU, resV):
# sample resolutions
self.resU, self.resV = resU, resV

# adapt a face to a surface
if isinstance(srf, TopoDS_Face):
self.face = srf
self.srf = BRep_Tool().Surface(srf)
else:
raise NotImplementedError, 'only TopoDS_Face instances supported'

# uv bounds
self.u_min, self.v_min, self.u_max, self.v_max = GeomLProp_SurfaceTool().Bounds(self.srf)

self.u, self.v = numpy.mgrid[self.u_min : self.u_max : complex(self.resU),
self.v_min : self.v_max : complex(self.resV)
]

# not used yet
self.coeffs_u, self.coeffs_v = spline_filter(self.u), spline_filter(self.v)

self.uv_grid = numpy.dstack((self.u, self.v))
self.curvature = GeomLProp_SLProps(self.srf,
self.u_min,
self.v_min,
1,
0.0001
)

self.cl = self._setup_trimmed()

def _setup_trimmed(self):
#tol = 1e-4
tol = 1e-9
u1,u2, v1,v2 = BRepTools().UVBounds(self.face)
dailen = (u2-u1)*(u2-u1) + (v2-v1)*(v2-v1)
#dailen = math.sqrt(dailen) / 400.
#dailen = math.sqrt(dailen) / 4000.
#tol = max([dailen, tol])
return BRepTopAdaptor_FClass2d(self.face, tol)

def is_uv_in_face_domain(self, u, v):
'''checks if curve is trimmed
'''
uv = gp_Pnt2d(u,v)
if self.cl.Perform(uv) == TopAbs_IN:
return True
else:
return False

def _sample_grid(self, curvatureType='gaussian'):
'''
samples the surface' curvature
curvature types are:
*gaussian ( default )
*max
*mean
*min
*normal
*tangent
*principal_curvature
*position
*umbilic
'''
self.curvature_grid = numpy.zeros(( self.uv_grid.shape[0], self.uv_grid.shape[1] ), numpy.float)
self.trimmed_grid = numpy.zeros_like(self.curvature_grid)

if curvatureType == 'gaussian':
sample = self.curvature.GaussianCurvature

elif curvatureType == None:
#===============================================================================
# if you just care about the distance map
#===============================================================================
pass

elif curvatureType == 'max':
sample = self.curvature.MaxCurvature

elif curvatureType == 'min':
sample = self.curvature.MinCurvature

elif curvatureType == 'mean':
sample = self.curvature.MeanCurvature

elif curvatureType == 'normal':
sample = self.curvature.Normal

elif curvatureType == 'tangent':
raise NotImplementedError, 'double value...'
def tangent():
tU = self.curvature.TangentU()
tV = self.curvature.TangentV()
return tU, tV
sample = tangent

elif curvatureType == 'principal_curvature':
raise NotImplementedError, 'double value...'
sample = self.curvature.CurvatureDirections

elif curvatureType == 'umbilic':
self.curvature_grid = numpy.zeros(( self.uv_grid.shape[0], self.uv_grid.shape[1] ), numpy.bool8)
sample = self.curvature.IsUmbilic

else:
raise AssertionError, '%s not a sampling type' % (curvatureType)

_trimmed_areas = []
_curvature_lowest = 1000

for indxA, a in enumerate(self.uv_grid):
for indxB, b in enumerate(a):
u,v = b
#print 'u,v', u,v
if curvatureType is not None:
self.curvature.SetParameters(u,v)
_curvature = sample()
if _curvature < _curvature_lowest:
_curvature_lowest = _curvature
self.curvature_grid[indxA, indxB] = _curvature
if not self.is_uv_in_face_domain(u, v):
_trimmed_areas.append((indxA, indxB))

for i in _trimmed_areas:
# black out those areas in the curvature map that are on the trimmed part of the face
self.curvature_grid[i[0], i[1]] = _curvature_lowest
# identify a trimmed area in the trimmed_grid
self.trimmed_grid[i[0], i[1]] = 255.0 #1.

return self.curvature_grid

def interpolate_uv_grid(self, _u, _v):
'''
vectorize this shit
@param _u:
@param _v:
'''
raise NotImplementedError
uuu = map_coordinates(self.coeffs_u, _u, prefilter=False)
vvv = map_coordinates(self.coeffs_v, _v, prefilter=False)
return uuu[0], vvv[0]

def sample_gaussian(self):
return self._sample_grid('gaussian')

def sample_max(self):
return self._sample_grid('max')

def sample_min(self):
return self._sample_grid('min')

def sample_mean(self):
return self._sample_grid('mean')

def sample_umbilic(self):
return self._sample_grid('umbilic')

def sample_trimmed(self):
return self._sample_grid(curvatureType=None)