在你的代码中，我没有看到三次均匀B样条曲线的基函数，而且我希望是三维的

对于三次均匀B样条曲线的基函数，可以通过递归地计算贝塞尔基函数来得到。对于三维情况，可以将二维向量扩展为三维向量，计算过程与二维情况类似。以下是一个C++代码示例，用于计算三次均匀B样条曲线的曲率半径：

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// 定义三维向量结构体
struct Vector3D {
    double x, y, z;
    Vector3D(double _x = 0.0, double _y = 0.0, double _z = 0.0) : x(_x), y(_y), z(_z) {}
};

// 计算向量的模长
double VectorLength(const Vector3D& vec) {
    return sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
}

// 计算向量的单位向量
Vector3D NormalizedVector(const Vector3D& vec) {
    double len = VectorLength(vec);
    if (len == 0.0) {
        return vec;
    } else {
        return Vector3D(vec.x / len, vec.y / len, vec.z / len);
    }
}

// 计算向量的旋转角度
double VectorAngle(const Vector3D& vec) {
    return atan2(vec.y, vec.x);
}

// 计算两个向量的叉积
Vector3D CrossProduct(const Vector3D& vec1, const Vector3D& vec2) {
    Vector3D result;
    result.x = vec1.y * vec2.z - vec1.z * vec2.y;
    result.y = vec1.z * vec2.x - vec1.x * vec2.z;
    result.z = vec1.x * vec2.y - vec1.y * vec2.x;
    return result;
}

// 计算三次均匀B样条曲线的基函数
double CubicBezierBasisFunction(double t, int i, int n) {
    if (n == 0) {
        if (i == 0 && t >= 0.0 && t < 1.0) {
            return 1.0;
        } else {
            return 0.0;
        }
    } else {
        double left = (t - i * 1.0 / n) / (1.0 / n);
        double right = ((i + n + 1) * 1.0 / n - t) / (1.0 / n);
        return left * CubicBezierBasisFunction(t, i, n - 1) + right * CubicBezierBasisFunction(t, i + 1, n - 1);
    }
}

// 计算三次均匀B样条曲线的曲率半径
double CalculateCurvatureRadius(const vector<Vector3D>& controlPoints) {
    // 计算曲线的一阶导数向量和二阶导数向量
    vector<Vector3D> firstDerivatives, secondDerivatives;
    for (int i = 0; i < controlPoints.size() - 1; ++i) {
        Vector3D firstDerivative((controlPoints[i + 1].x - controlPoints[i].x) * 3.0,
                                 (controlPoints[i + 1].y - controlPoints[i].y) * 3.0,
                                 (controlPoints[i + 1].z - controlPoints[i].z) * 3.0);
        firstDerivatives.push_back(firstDerivative);
        if (i < controlPoints.size() - 2) {
            Vector3D secondDerivative((controlPoints[i + 2].x - controlPoints[i].x) * 3.0 - firstDerivative.x,
                                      (controlPoints[i + 2].y - controlPoints[i].y) * 3.0 - firstDerivative.y,
                                      (controlPoints[i + 2].z - controlPoints[i].z) * 3.0 - firstDerivative.z);
            secondDerivatives.push_back(secondDerivative);
        }
    }
    
    // 计算每个控制点的曲率
    vector<double> curvatures;
    for (int i = 0; i < controlPoints.size() - 2; ++i) {
        // 计算切向量
        Vector3D tangent = NormalizedVector(firstDerivatives[i]);
        
        // 计算法向量
        Vector3D normal = CrossProduct(firstDerivatives[i], secondDerivatives[i]);
        normal = NormalizedVector(normal);
        
        // 计算曲率
        double curvature = VectorLength(CrossProduct(secondDerivatives[i], normal)) / pow(VectorLength(firstDerivatives[i]), 2.0);
        curvatures.push_back(curvature);
    }
    
    // 计算曲线的曲率半径
    double radius = 0.0;
    for (int i = 0; i < curvatures.size(); ++i) {
        if (curvatures[i] != 0.0) {
            radius = 1.0 / curvatures[i];
            break;
        }
    }
    
    return radius;
}

int main() {
    // 定义控制点
    vector<Vector3D> controlPoints = {
        Vector3D(0.0, 0.0, 0.0),
        Vector3D(1.0, 1.0, 1.0),
        Vector3D(2.0, 0.0, 2.0),
        Vector3D(3.0, 1.0, 3.0),
        Vector3D(4.0, 0.0, 4.0)
    };
    
    // 计算曲率半径
    double radius = CalculateCurvatureRadius(controlPoints);
    
    // 输出结果
    cout << "曲率半径为：" << radius << endl;
    
    return 0;
}

需要注意的是，此示例仅供参考，可能存在不足之处，实际使用时需要根据具体情况进行调整。