siren2 0.1.2

data/ext/siren2/src/shape/chunk.cpp

@@ -0,0 +1,65 @@
+#ifdef SR_ENABLE_CHUNK
+
+#include "shape/chunk.h"
+
+VALUE sr_cChunk;
+
+SR_SHAPE_GET(CompSolid, chunk)
+SR_SHAPE_CHECK(CompSolid, chunk)
+
+bool siren_chunk_install()
+{
+  SR_SHAPE_INIT(CompSolid)
+  rb_define_method(sr_cChunk, "initialize", RUBY_METHOD_FUNC(siren_chunk_init),   -1);
+  rb_define_method(sr_cChunk, "to_solid",  RUBY_METHOD_FUNC(siren_chunk_to_solid), -1);
+  return true;
+}
+
+struct RClass* siren_chunk_rclass()
+{
+  struct RClass* sr_mSiren = rb_module_get("Siren");
+  return rb_class_ptr(_const_get(rb_obj_value(sr_mSiren), rb_intern_lit("Chunk")));
+}
+
+VALUE siren_chunk_obj()
+{
+  struct RClass* sr_mSiren = rb_module_get("Siren");
+  return rb_const_get(rb_obj_value(sr_mSiren), rb_intern_lit("Chunk"));
+}
+
+VALUE siren_chunk_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE* a;
+  rb_scan_args(argc, argv, "1", &a);
+  int len = RARRAY_LEN(a);
+
+  TopoDS_CompSolid cs;
+  TopoDS_Builder builder;
+  builder.MakeCompSolid(cs);
+
+  for (int i = 0; i < len; i++) {
+    if (_array_p(a[i])) {
+      for (int j = 0; j < RARRAY_LEN(a[i]); j++) {
+        auto solid = siren_solid_get(RARRAY_AREF(a[i], j));
+        builder.Add(cs, solid);
+      }
+    }
+    else {
+      auto solid = siren_solid_get(a[i]);
+      builder.Add(cs, solid);
+    }
+  }
+
+  auto p = siren_shape_get(self);
+  *p = cs;
+  return self;
+}
+
+VALUE siren_chunk_to_solid(int argc, VALUE* argv, VALUE self)
+{
+  auto cs = siren_chunk_get(self);
+  auto solid = BRepBuilderAPI_MakeSolid(cs);
+  return siren_shape_new(solid);
+}
+
+#endif

data/ext/siren2/src/shape/compound.cpp

@@ -0,0 +1,96 @@
+#include "shape/compound.h"
+
+#define rb_array_p(x) RB_TYPE_P(x, T_ARRAY)
+
+VALUE sr_cCompound;
+
+SR_SHAPE_GET(Compound, compound)
+SR_SHAPE_CHECK(Compound, compound)
+
+bool siren_compound_install()
+{
+  SR_SHAPE_INIT(Compound)
+  rb_define_method(sr_cCompound, "initialize", RUBY_METHOD_FUNC(siren_compound_init),   -1);
+  rb_define_method(sr_cCompound, "push",       RUBY_METHOD_FUNC(siren_compound_push),   -1);
+  rb_define_method(sr_cCompound, "<<",         RUBY_METHOD_FUNC(siren_compound_push),   -1);
+  rb_define_method(sr_cCompound, "delete",     RUBY_METHOD_FUNC(siren_compound_delete), -1);
+  return true;
+}
+
+VALUE siren_compound_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE* a;
+  VALUE len;
+  rb_scan_args(argc, argv, "*", &a, &len);
+
+  TopoDS_Compound comp;
+  BRep_Builder B;
+  B.MakeCompound(comp);
+
+  for (int i = 0; i < len; i++) {
+    VALUE arg = *(a + i);
+    if (rb_array_p(arg)) {
+      VALUE subary = rb_funcall(arg, rb_intern("flatten"), 0);
+      for (int j = 0; j < RARRAY_LEN(subary); j++) {
+        TopoDS_Shape* shape = siren_shape_get(RARRAY_AREF(subary, j));
+        B.Add(comp, *shape);
+      }
+    }
+    else {
+      TopoDS_Shape* shape = siren_shape_get(arg);
+      B.Add(comp, *shape);
+    }
+  }
+
+  auto p = siren_shape_get(self);
+  *p = comp;
+  return self;
+}
+
+VALUE siren_compound_push(int argc, VALUE* argv, VALUE self)
+{
+  VALUE* a;
+  VALUE len;
+  rb_scan_args(argc, argv, "*", &a, &len);
+  TopoDS_Compound comp = siren_compound_get(self);
+  BRep_Builder B;
+  for (int i = 0; i < len; i++) {
+    VALUE arg = *(a + i);
+    if (rb_array_p(arg)) {
+      VALUE subary = rb_funcall(arg, rb_intern("flatten"), 0);
+      for (int j = 0; j < RARRAY_LEN(subary); j++) {
+        TopoDS_Shape* shape = siren_shape_get(RARRAY_AREF(subary, j));
+        B.Add(comp, *shape);
+      }
+    }
+    else {
+      TopoDS_Shape* shape = siren_shape_get(arg);
+      B.Add(comp, *shape);
+    }
+  }
+  return self;
+}
+
+VALUE siren_compound_delete(int argc, VALUE* argv, VALUE self)
+{
+  VALUE* a;
+  VALUE len;
+  rb_scan_args(argc, argv, "*", &a, &len);
+  TopoDS_Compound comp = siren_compound_get(self);
+  BRep_Builder B;
+  for (int i = 0; i < len; i++) {
+    VALUE arg = *(a + i);
+    if (rb_array_p(arg)) {
+      VALUE subary = rb_funcall(arg, rb_intern("flatten"), 0);
+      for (int j = 0; j < RARRAY_LEN(subary); j++) {
+        TopoDS_Shape* shape = siren_shape_get(RARRAY_AREF(subary, j));
+        B.Remove(comp, *shape);
+      }
+    }
+    else {
+      TopoDS_Shape* shape = siren_shape_get(arg);
+      B.Remove(comp, *shape);
+    }
+  }
+  return self;
+}

data/ext/siren2/src/shape/edge.cpp

@@ -0,0 +1,254 @@
+#include "shape/edge.h"
+
+VALUE sr_cEdge;
+
+SR_SHAPE_GET(Edge, edge)
+SR_SHAPE_CHECK(Edge, edge)
+
+bool siren_edge_install()
+{
+  SR_SHAPE_INIT(Edge)
+  rb_define_method(sr_cEdge, "initialize", RUBY_METHOD_FUNC(siren_edge_init),      -1);
+  rb_define_method(sr_cEdge, "sp",         RUBY_METHOD_FUNC(siren_edge_sp),        -1);
+  rb_define_method(sr_cEdge, "tp",         RUBY_METHOD_FUNC(siren_edge_tp),        -1);
+  rb_define_method(sr_cEdge, "to_pts",     RUBY_METHOD_FUNC(siren_edge_to_pts),    -1);
+  rb_define_method(sr_cEdge, "param",      RUBY_METHOD_FUNC(siren_edge_param),     -1);
+  rb_define_method(sr_cEdge, "to_xyz",     RUBY_METHOD_FUNC(siren_edge_to_xyz),    -1);
+  rb_define_method(sr_cEdge, "curvature",  RUBY_METHOD_FUNC(siren_edge_curvature), -1);
+  rb_define_method(sr_cEdge, "tangent",    RUBY_METHOD_FUNC(siren_edge_tangent),   -1);
+  rb_define_method(sr_cEdge, "extrema",    RUBY_METHOD_FUNC(siren_edge_extrema),   -1);
+  rb_define_method(sr_cEdge, "split",      RUBY_METHOD_FUNC(siren_edge_split),     -1);
+  rb_define_method(sr_cEdge, "trim",       RUBY_METHOD_FUNC(siren_edge_trim),      -1);
+  rb_define_method(sr_cEdge, "terms",      RUBY_METHOD_FUNC(siren_edge_terms),     -1);
+  rb_define_method(sr_cEdge, "curve",      RUBY_METHOD_FUNC(siren_edge_curve),     -1);
+  return true;
+}
+
+VALUE siren_edge_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE curve;
+  VALUE sp = DBL2NUM(0.0), tp = DBL2NUM(1.0);
+  rb_scan_args(argc, argv, "12", &curve, &sp, &tp);
+  auto phgcurve = siren_curve_get(curve);
+  TopoDS_Shape edge;
+  if (argc == 1) {
+    edge = BRepBuilderAPI_MakeEdge(*phgcurve);
+  }
+  else if (argc == 2) {
+    rb_raise(Qnil,
+        "The start parameter specified without a terminal parameter.");
+  }
+  else {
+    Check_Type(sp, T_FLOAT);
+    Check_Type(tp, T_FLOAT);
+    try {
+      edge = BRepBuilderAPI_MakeEdge(*phgcurve, NUM2DBL(sp), NUM2DBL(tp));
+      if (edge.IsNull()) {
+        rb_raise(Qnil, "Failed to make Edge from the Curve.");
+      }
+    }
+    catch (...) {
+      rb_raise(Qnil, "Failed to make Edge from the Curve.");
+    }
+  }
+  auto p = siren_shape_get(self);
+  *p = edge;
+  return self;
+}
+
+VALUE siren_edge_sp(int argc, VALUE* argv, VALUE self)
+{
+  BRepAdaptor_Curve bracurve(siren_edge_get(self));
+  gp_Pnt sp = bracurve.Value(bracurve.FirstParameter());
+  return siren_pnt_to_ary(sp);
+}
+
+VALUE siren_edge_tp(int argc, VALUE* argv, VALUE self)
+{
+  BRepAdaptor_Curve bracurve(siren_edge_get(self));
+  gp_Pnt tp = bracurve.Value(bracurve.LastParameter());
+  return siren_pnt_to_ary(tp);
+}
+
+VALUE siren_edge_to_pts(int argc, VALUE* argv, VALUE self)
+{
+  VALUE deflect;
+  VALUE lintol;
+  rb_scan_args(argc, argv, "02", &deflect, &lintol);
+  if (argc < 1) {
+    deflect = DBL2NUM(1.0e-7);
+  }
+  if (argc < 2) {
+    lintol = DBL2NUM(1.0e-7);
+  }
+  TopoDS_Edge edge = siren_edge_get(self);
+  BRepAdaptor_Curve adaptor(edge);
+  double first_param, last_param;
+  first_param = adaptor.FirstParameter();
+  last_param = adaptor.LastParameter();
+
+  VALUE line = rb_ary_new();
+
+  GCPnts_UniformDeflection unidef(adaptor, NUM2DBL(deflect));
+  if (unidef.IsDone()) {
+    // first point
+    gp_Pnt p = adaptor.Value(first_param);
+    rb_ary_push(line, siren_pnt_to_ary(p));
+    gp_Pnt prev = p;
+
+    for (int i=1; i<=unidef.NbPoints(); i++) {
+      p = unidef.Value(i);
+      if (prev.IsEqual(p, NUM2DBL(lintol))) {
+        continue;
+      }
+      rb_ary_push(line, siren_pnt_to_ary(p));
+      prev = p;
+    }
+    // last point
+    p = adaptor.Value(last_param);
+    if (!prev.IsEqual(p, NUM2DBL(lintol))) {
+      rb_ary_push(line, siren_pnt_to_ary(p));
+    }
+  }
+  return line;
+}
+
+VALUE siren_edge_param(int argc, VALUE* argv, VALUE self)
+{
+  VALUE xyz;
+  VALUE tol = DBL2NUM(1.0e-7);
+  rb_scan_args(argc, argv, "11", &xyz, &tol);
+
+  TopoDS_Edge edge = siren_edge_get(self);
+
+  ShapeAnalysis_Curve ana;
+  BRepAdaptor_Curve gcurve(edge);
+  gp_Pnt p = siren_ary_to_pnt(xyz);
+  gp_Pnt pp;
+  Standard_Real param;
+  Standard_Real distance = ana.Project(gcurve, p, NUM2DBL(tol), pp, param);
+
+  if (fabs(distance) > tol) {
+    rb_raise(Qnil, "Specified position is not on the edge.");
+  }
+
+  return (param);
+}
+
+VALUE siren_edge_to_xyz(int argc, VALUE* argv, VALUE self)
+{
+  VALUE param;
+  rb_scan_args(argc, argv, "1", &param);
+  Check_Type(param, T_FLOAT);
+  BRepAdaptor_Curve C(siren_edge_get(self));
+  gp_Pnt p;
+  gp_Vec v1, v2;
+  C.D2(NUM2DBL(param), p, v1, v2);
+  return siren_pnt_to_ary(p);
+}
+
+VALUE siren_edge_curvature(int argc, VALUE* argv, VALUE self)
+{
+  VALUE param;
+  rb_scan_args(argc, argv, "1", &param);
+  Check_Type(param, T_FLOAT);
+  BRepAdaptor_Curve C(siren_edge_get(self));
+  gp_Pnt p;
+  gp_Vec v1, v2;
+  C.D2(NUM2DBL(param), p, v1, v2);
+  return siren_vec_new(v2.X(), v2.Y(), v2.Z());
+}
+
+VALUE siren_edge_tangent(int argc, VALUE* argv, VALUE self)
+{
+  VALUE param;
+  rb_scan_args(argc, argv, "1", &param);
+  Check_Type(param, T_FLOAT);
+  BRepAdaptor_Curve C(siren_edge_get(self));
+  gp_Pnt p;
+  gp_Vec v1, v2;
+  C.D2(NUM2DBL(param), p, v1, v2);
+  return siren_vec_new(v1.X(), v1.Y(), v1.Z());
+}
+
+VALUE siren_edge_terms(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Edge edge = siren_edge_get(self);
+  Standard_Real first, last;
+  BRep_Tool::Curve(edge, first, last);
+  VALUE res = rb_ary_new();
+  rb_ary_push(res, DBL2NUM(first));
+  rb_ary_push(res, DBL2NUM(last));
+  return res;
+}
+
+VALUE siren_edge_curve(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Edge edge = siren_edge_get(self);
+  // // set property
+  // Standard_Real first, last;
+  // handle<Geom_Curve> hgcurve = BRep_Tool::Curve(edge, first, last);
+  // rb_obj_iv_set(rb_obj_value(cls_edge), rb_intern_lit("@curve"), siren_curve_new(&hgcurve));
+  // // get property
+  // return rb_iv_get(self, rb_intern_lit("@curve"));
+  Standard_Real first, last;
+  handle<Geom_Curve> hgcurve = BRep_Tool::Curve(edge, first, last);
+  return siren_curve_new(hgcurve);
+}
+
+VALUE siren_edge_extrema(int argc, VALUE* argv, VALUE self)
+{
+  VALUE other;
+  rb_scan_args(argc, argv, "1", &other);
+  siren_edge_check(other);
+  TopoDS_Edge e1 = siren_edge_get(self);
+  TopoDS_Edge e2 = siren_edge_get(other);
+  BRepExtrema_ExtCC ext(e1, e2);
+  if (!ext.IsDone()) {
+    rb_raise(Qnil, "Failed to get extrema points.");
+  }
+  else if (ext.IsParallel()) {
+    return Qnil;
+  }
+  VALUE p1s = rb_ary_new();
+  VALUE p2s = rb_ary_new();
+  for (int i = 1; i <= ext.NbExt(); i++) {
+    rb_ary_push(p1s, DBL2NUM(ext.ParameterOnE1(i)));
+    rb_ary_push(p2s, DBL2NUM(ext.ParameterOnE2(i)));
+  }
+  VALUE res[2] = { p1s, p2s };
+  return rb_ary_new_from_values(2, res);
+}
+
+VALUE siren_edge_split(int argc, VALUE* argv, VALUE self)
+{
+  VALUE param;
+  rb_scan_args(argc, argv, "1", &param);
+  Check_Type(param, T_FLOAT);
+  Standard_Real first, last;
+  TopoDS_Edge e = siren_edge_get(self);
+  handle<Geom_Curve> gc  = BRep_Tool::Curve(e, first, last);
+  if (NUM2DBL(param) <= first || NUM2DBL(param) >= last) {
+    rb_raise(Qnil, "Specified parameter is out of range of curve parameter.");
+  }
+  TopoDS_Edge e1 = BRepBuilderAPI_MakeEdge(gc, first, NUM2DBL(param));
+  TopoDS_Edge e2 = BRepBuilderAPI_MakeEdge(gc, NUM2DBL(param), last);
+  VALUE res[] = { siren_shape_new(e1), siren_shape_new(e2) };
+  return rb_ary_new_from_values(2, res);
+}
+
+VALUE siren_edge_trim(int argc, VALUE* argv, VALUE self)
+{
+  VALUE first2, last2;
+  rb_scan_args(argc, argv, "2", &first2, &last2);
+  Check_Type(first2, T_FLOAT);
+  Check_Type(last2, T_FLOAT);
+  if (NUM2DBL(first2) == NUM2DBL(last2)) {
+    rb_raise(Qnil, "Specified parameter has same value.");
+  }
+  Standard_Real first, last;
+  TopoDS_Edge e = siren_edge_get(self);
+  handle<Geom_Curve> gc  = BRep_Tool::Curve(e, first, last);
+  TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(gc, NUM2DBL(first2), NUM2DBL(last2));
+  return siren_shape_new(edge);
+}

data/ext/siren2/src/shape/face.cpp

@@ -0,0 +1,366 @@
+#include "shape/face.h"
+
+VALUE sr_cFace;
+
+SR_SHAPE_GET(Face, face)
+SR_SHAPE_CHECK(Face, face)
+
+bool siren_face_install()
+{
+  SR_SHAPE_INIT(Face)
+  rb_define_method(sr_cFace, "initialize", RUBY_METHOD_FUNC(siren_shape_init),     -1);
+  rb_define_method(sr_cFace, "normal",     RUBY_METHOD_FUNC(siren_face_normal),    -1);
+  rb_define_method(sr_cFace, "to_bezier",  RUBY_METHOD_FUNC(siren_face_to_bezier), -1);
+  rb_define_method(sr_cFace, "split",      RUBY_METHOD_FUNC(siren_face_split),     -1);
+  rb_define_method(sr_cFace, "triangle",   RUBY_METHOD_FUNC(siren_face_triangle),  -1);
+  rb_define_singleton_method(sr_cFace, "plane",    RUBY_METHOD_FUNC(siren_face_plane),    -1);
+  rb_define_singleton_method(sr_cFace, "face",     RUBY_METHOD_FUNC(siren_face_face),     -1);
+  rb_define_singleton_method(sr_cFace, "infplane", RUBY_METHOD_FUNC(siren_face_infplane), -1);
+  rb_define_singleton_method(sr_cFace, "polygon",  RUBY_METHOD_FUNC(siren_face_polygon),  -1);
+  rb_define_singleton_method(sr_cFace, "bzsurf",   RUBY_METHOD_FUNC(siren_face_bzsurf),   -1);
+  rb_define_singleton_method(sr_cFace, "bssurf",   RUBY_METHOD_FUNC(siren_face_bssurf),   -1);
+  return true;
+}
+
+VALUE siren_face_normal(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Face f = siren_face_get(self);
+  Standard_Real umin, umax, vmin, vmax;
+  BRepTools::UVBounds(f, umin, umax, vmin, vmax);
+  handle<Geom_Surface> gsurf = BRep_Tool::Surface(f);
+  GeomLProp_SLProps props(gsurf, umin, vmin, 1, 0.01);
+  gp_Dir n = props.Normal();
+  return siren_vec_new(n.X(), n.Y(), n.Z());
+}
+
+VALUE siren_face_to_bezier(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Face face = siren_face_get(self);
+  handle<Geom_Surface> gsurf  = BRep_Tool::Surface(face);
+  handle<Geom_BSplineSurface> gbssurf = handle<Geom_BSplineSurface>::DownCast(gsurf);
+  if (gbssurf.IsNull()) {
+    rb_raise(Qnil, "Specified shape is not B-Spline surface.");
+  }
+
+  TopoDS_Compound comp;
+  BRep_Builder B;
+  B.MakeCompound(comp);
+
+  GeomConvert_BSplineSurfaceToBezierSurface converter(gbssurf);
+
+  TColGeom_Array2OfBezierSurface ary(1, converter.NbUPatches(), 1, converter.NbVPatches());
+  converter.Patches(ary);
+
+  for (int r = ary.LowerRow(); r <= ary.UpperRow(); r++) {
+    for (int c = ary.LowerCol(); c <= ary.UpperCol(); c++) {
+      handle<Geom_BezierSurface> gbzsurf = ary.Value(r, c);
+      TopoDS_Face patch = BRepBuilderAPI_MakeFace(gbzsurf, 1.0e-1);
+      B.Add(comp, patch);
+    }
+  }
+
+  return siren_shape_new(comp);
+}
+
+VALUE siren_face_split(int argc, VALUE* argv, VALUE self)
+{
+  VALUE obj;
+  rb_scan_args(argc, argv, "o", &obj);
+
+  TopoDS_Face face = siren_face_get(self);
+  BRepFeat_SplitShape splitter(face);
+
+  TopoDS_Shape shape = *siren_shape_get(obj);
+  switch (shape.ShapeType()) {
+  case TopAbs_WIRE:
+    splitter.Add(TopoDS::Wire(shape), face);
+    break;
+  case TopAbs_EDGE:
+    splitter.Add(TopoDS::Edge(shape), face);
+    break;
+  case TopAbs_COMPOUND:
+    splitter.Add(TopoDS::Compound(shape), face);
+    break;
+  default:
+    rb_raise(Qnil, "Incorrect argument specified.");
+  }
+  try {
+    splitter.Build();
+  }
+  catch (...) {
+    rb_raise(Qnil, "Failed to split the face.");
+  }
+  if (!splitter.IsDone()) {
+    rb_raise(Qnil, "Failed to split the face.");
+  }
+  return siren_shape_new(splitter.Shape());
+}
+
+VALUE siren_face_triangle(int argc, VALUE* argv, VALUE self)
+{
+  VALUE deflection, angle;
+  rb_scan_args(argc, argv, "11", &deflection, &angle);
+
+  Check_Type(deflection, T_FLOAT);
+  Check_Type(angle, T_FLOAT);
+
+  VALUE result = rb_ary_new();
+
+  TopoDS_Face face = siren_face_get(self);
+  BRepTools::Update(face);
+
+  BRepMesh_IncrementalMesh imesh(face, NUM2DBL(deflection), Standard_False, NUM2DBL(angle));
+  imesh.Perform();
+  if (!imesh.IsDone()) {
+    rb_raise(Qnil, "Failed to incremantal mesh.");
+  }
+
+  TopoDS_Face face2 = TopoDS::Face(imesh.Shape());
+
+  TopLoc_Location loc;
+  // Do triangulation
+  handle<Poly_Triangulation> poly = BRep_Tool::Triangulation(face2, loc);
+  if (poly.IsNull()) {
+    rb_raise(Qnil, "Failed to triangulation.");
+  }
+
+  const Poly_Array1OfTriangle& tris = poly->Triangles();
+
+  for (Standard_Integer i = tris.Lower(); i <= tris.Upper(); i++) {
+
+    const Poly_Triangle& tri = tris.Value(i);
+
+    // Node indexes
+    Standard_Integer n1, n2, n3;
+    if (face2.Orientation() != TopAbs_REVERSED) {
+      tri.Get(n1, n2, n3);
+    }
+    else {
+      tri.Get(n3, n2, n1);
+    }
+
+    gp_Pnt p1 = poly->Nodes().Value(n1);
+    gp_Pnt p2 = poly->Nodes().Value(n2);
+    gp_Pnt p3 = poly->Nodes().Value(n3);
+
+    p1.Transform(loc);
+    p2.Transform(loc);
+    p3.Transform(loc);
+
+    gp_Vec u = gp_Vec(p2.XYZ() - p1.XYZ());
+    gp_Vec v = gp_Vec(p3.XYZ() - p1.XYZ());
+
+    gp_Vec norm(
+        u.Y() * v.Z() - u.Z() * v.Y(),
+        u.Z() * v.X() - u.X() * v.Z(),
+        u.X() * v.Y() - u.Y() * v.X());
+    if (norm.Magnitude() <= 0) {
+      continue;
+    }
+    norm.Normalize();
+
+    VALUE trimesh = rb_ary_new();
+    rb_ary_push(trimesh, siren_pnt_to_ary(p1));
+    rb_ary_push(trimesh, siren_pnt_to_ary(p2));
+    rb_ary_push(trimesh, siren_pnt_to_ary(p3));
+    rb_ary_push(trimesh, siren_vec_to_ary(u));
+    rb_ary_push(trimesh, siren_vec_to_ary(v));
+    rb_ary_push(trimesh, siren_vec_to_ary(norm));
+
+    rb_ary_push(result, trimesh);
+  }
+
+  return result;
+}
+
+VALUE siren_face_plane(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pos, norm, vx;
+  VALUE umin, umax, vmin, vmax;
+  rb_scan_args(argc, argv, "7", &pos, &norm, &vx, &umin, &umax, &vmin, &vmax);
+  Check_Type(umin, T_FLOAT);
+  Check_Type(umax, T_FLOAT);
+  Check_Type(vmin, T_FLOAT);
+  Check_Type(vmax, T_FLOAT);
+  try {
+    gp_Pln _pln(siren_ary_to_ax2(pos, norm, vx));
+    BRepBuilderAPI_MakeFace face(_pln, NUM2DBL(umin), NUM2DBL(umax), NUM2DBL(vmin), NUM2DBL(vmax));
+    return siren_shape_new(face.Shape());
+  }
+  catch (...) {
+    rb_raise(Qnil, "Failed to make a plane. "
+        "vx has same value with the normal vector.");
+    return Qnil;
+  }
+}
+
+VALUE siren_face_face(int argc, VALUE* argv, VALUE self)
+{
+  VALUE wire;
+  VALUE force_plane;
+  rb_scan_args(argc, argv, "2", &wire, &force_plane);
+
+  siren_wire_check(wire);
+
+  TopoDS_Shape* s = siren_shape_get(wire);
+  TopoDS_Wire w = TopoDS::Wire(*s);
+  TopoDS_Face face = BRepBuilderAPI_MakeFace(w, (Standard_Boolean)(force_plane == Qtrue));
+  return siren_shape_new(face);
+}
+
+VALUE siren_face_infplane(int argc, VALUE* argv, VALUE self)
+{
+  VALUE orig, dir;
+  rb_scan_args(argc, argv, "2", &orig, &dir);
+  gp_Pln pln(siren_ary_to_pnt(orig), siren_ary_to_dir(dir));
+  TopoDS_Face face = BRepBuilderAPI_MakeFace(pln);
+  return siren_shape_new(face);
+}
+
+VALUE siren_face_polygon(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pts;
+  VALUE force_plane = Qfalse;
+  rb_scan_args(argc, argv, "11", &pts, &force_plane);
+
+  BRepBuilderAPI_MakePolygon mp;
+
+  for (int i=0; i<RARRAY_LEN(pts); i++) {
+    mp.Add(siren_ary_to_pnt(RARRAY_AREF(pts, i)));
+  }
+
+  mp.Close();
+  BRepBuilderAPI_MakeFace mf(mp.Wire(), (Standard_Boolean)(force_plane == Qtrue));
+  mf.Build();
+
+  if (!mf.IsDone()) {
+    rb_raise(Qnil, "Failed to make a polygon.");
+  }
+
+  return siren_shape_new(mf.Shape());
+}
+
+VALUE siren_face_bzsurf(int argc, VALUE* argv, VALUE self)
+{
+  VALUE ptary, wtary;
+  rb_scan_args(argc, argv, "11", &ptary, &wtary);
+
+  int rlen = RARRAY_LEN(ptary);
+  int clen = RARRAY_LEN(RARRAY_AREF(ptary, 0));
+
+  TColgp_Array2OfPnt poles(0, rlen-1, 0, clen-1);
+
+  for (int r=0; r<rlen; r++) {
+    VALUE ar = RARRAY_AREF(ptary, r);
+    for (int c=0; c<clen; c++) {
+      poles.SetValue(r, c, siren_ary_to_pnt(RARRAY_AREF(ar, c)));
+    }
+  }
+
+  opencascade::handle<Geom_BezierSurface> s = nullptr;
+
+  if (argc == 2) {
+    TColStd_Array2OfReal weights(0, rlen-1, 0, clen-1);
+    for (int r=0; r<rlen; r++) {
+      VALUE ar = RARRAY_AREF(wtary, r);
+      for (int c=0; c<clen; c++) {
+        VALUE val = RARRAY_AREF(ar, c);
+        weights.SetValue(r, c, NUM2DBL(val));
+      }
+    }
+    s = new Geom_BezierSurface(poles, weights);
+  }
+  else {
+    s = new Geom_BezierSurface(poles);
+  }
+
+  return siren_shape_new(BRepBuilderAPI_MakeFace(s, 1.0e-7));
+}
+
+VALUE siren_face_bssurf(int argc, VALUE* argv, VALUE self)
+{
+  VALUE _udeg, _vdeg;
+  VALUE _ar_ukm, _ar_vkm;
+  VALUE _pol;
+  VALUE _wire;
+  rb_scan_args(argc, argv, "51", &_udeg, &_ar_ukm, &_vdeg, &_ar_vkm, &_pol, &_wire);
+
+  bool has_contour = argc == 6;
+  if (has_contour) {
+    siren_wire_check(_wire);
+  }
+
+  Standard_Integer udeg = NUM2INT(_udeg);
+  Standard_Integer nbuknots = RARRAY_LEN(_ar_ukm);
+  Standard_Integer nbuknots_pure = 0;
+  TColStd_Array1OfReal uknots(1, nbuknots);
+  TColStd_Array1OfInteger umults(1, nbuknots);
+  for (int i=1; i<=nbuknots; i++) {
+    VALUE item = RARRAY_AREF(_ar_ukm, i - 1);
+    VALUE knot = RARRAY_AREF(item, 0);
+    VALUE mult = RARRAY_AREF(item, 1);
+    uknots(i) = NUM2DBL(knot);
+    umults(i) = NUM2INT(mult);
+    nbuknots_pure += umults(i);
+  }
+  Standard_Integer nbupoles = nbuknots_pure - udeg - 1;
+
+  Standard_Integer vdeg = NUM2INT(_vdeg);
+  Standard_Integer nbvknots = RARRAY_LEN(_ar_vkm);
+  Standard_Integer nbvknots_pure = 0;
+  TColStd_Array1OfReal vknots(1, nbvknots);
+  TColStd_Array1OfInteger vmults(1, nbvknots);
+  for (int i=1; i<=nbvknots; i++) {
+    VALUE item = RARRAY_AREF(_ar_vkm, i - 1);
+    VALUE knot = RARRAY_AREF(item, 0);
+    VALUE mult = RARRAY_AREF(item, 1);
+    vknots(i) = NUM2DBL(knot);
+    vmults(i) = NUM2INT(mult);
+    nbvknots_pure += vmults(i);
+  }
+  Standard_Integer nbvpoles = nbvknots_pure - vdeg - 1;
+
+  TColgp_Array2OfPnt   poles  (1, nbupoles, 1, nbvpoles);
+  TColStd_Array2OfReal weights(1, nbupoles, 1, nbvpoles);
+
+  for (int v=1; v <= nbvpoles; v++) {
+    VALUE vitem = RARRAY_AREF(_pol, v - 1);
+    for (int u=1; u <= nbupoles; u++) {
+      VALUE uitem = RARRAY_AREF(vitem, u - 1);
+      poles.SetValue(u, v, siren_ary_to_pnt(RARRAY_AREF(uitem, 0)));
+      weights.SetValue(u, v, NUM2DBL(RARRAY_AREF(uitem, 1)));
+    }
+  }
+
+  handle<Geom_BSplineSurface> hg_bssurf
+    = new Geom_BSplineSurface(poles, weights, uknots, vknots, umults, vmults, udeg, vdeg);
+  TopoDS_Shape shape;
+  if (has_contour) {
+    TopoDS_Shape* s = siren_shape_get(_wire);
+    TopoDS_Wire w = TopoDS::Wire(*s);
+    shape = BRepBuilderAPI_MakeFace(hg_bssurf, w, Standard_True);
+    // Fix a face
+    opencascade::handle<ShapeFix_Shape> sfs = new ShapeFix_Shape();
+    sfs->Init(shape);
+    sfs->FixFaceTool()->FixAddNaturalBoundMode() = 1;
+    sfs->FixFaceTool()->FixIntersectingWiresMode() = 1;
+    sfs->FixFaceTool()->FixLoopWiresMode() = 1;
+    sfs->FixFaceTool()->FixOrientationMode() = 1;
+    sfs->FixFaceTool()->FixPeriodicDegeneratedMode() = 1;
+    sfs->FixFaceTool()->FixSmallAreaWireMode() = 1;
+    sfs->FixFaceTool()->FixSplitFaceMode() = 1;
+    sfs->FixFaceTool()->FixWireMode() = 1;
+    sfs->SetPrecision(1.0);
+    sfs->SetMinTolerance(1.0e-1);
+    sfs->SetMaxTolerance(1.0);
+    sfs->Perform();
+    shape = sfs->Shape();
+    // End of fix
+  }
+  else {
+    Standard_Real toldegen = 1.0e-1;
+    shape = BRepBuilderAPI_MakeFace(hg_bssurf, toldegen);
+  }
+
+  return siren_shape_new(shape);
+}