siren2 0.1.2

data/ext/siren2/src/io/stl.cpp

@@ -0,0 +1,22 @@
+#include "io/stl.h"
+
+bool siren_stl_install()
+{
+  rb_define_method(sr_mSiren, "load_stl", RUBY_METHOD_FUNC(siren_stl_load), -1);
+  return true;
+}
+
+VALUE siren_stl_load(int argc, VALUE* argv, VALUE self)
+{
+  VALUE path;
+  rb_scan_args(argc, argv, "1", &path);
+
+  TopoDS_Shape shape;
+  StlAPI::Read(shape, (Standard_CString)RSTRING_PTR(path));
+
+  if (shape.IsNull()) {
+    rb_raise(Qnil, "Failed to load STL from %S.", (wchar_t*)RSTRING_PTR(path));
+  }
+
+  return siren_shape_new(shape);
+}

data/ext/siren2/src/offset.cpp

@@ -0,0 +1,256 @@
+#include "offset.h"
+
+bool siren_offset_install()
+{
+#if 0
+  // Class method
+  rb_define_class_method(sr_mSiren, "sweep_vec",       RUBY_METHOD_FUNC(siren_offset_sweep_vec),       MRB_ARGS_REQ(2));
+  rb_define_class_method(sr_mSiren, "sweep_path",      RUBY_METHOD_FUNC(siren_offset_sweep_path),      MRB_ARGS_REQ(2) | MRB_ARGS_OPT(4));
+  rb_define_class_method(sr_mSiren, "loft",            RUBY_METHOD_FUNC(siren_offset_loft),            MRB_ARGS_REQ(1) | MRB_ARGS_OPT(3));
+  rb_define_class_method(sr_mSiren, "offset_geomsurf", RUBY_METHOD_FUNC(siren_offset_offset_geomsurf), MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1));
+  rb_define_class_method(sr_mSiren, "offset",          RUBY_METHOD_FUNC(siren_offset_offset),          MRB_ARGS_REQ(3) | MRB_ARGS_OPT(5));
+  rb_define_class_method(sr_mSiren, "offset_shape",    RUBY_METHOD_FUNC(siren_offset_offset_shape),    MRB_ARGS_REQ(3) | MRB_ARGS_OPT(4));
+  rb_define_class_method(sr_mSiren, "pipe",            RUBY_METHOD_FUNC(siren_offset_pipe),            MRB_ARGS_REQ(2) | MRB_ARGS_OPT(2));
+#endif
+  // For mix-in
+  rb_define_method(sr_mSiren, "sweep_vec",       RUBY_METHOD_FUNC(siren_offset_sweep_vec),       -1);
+  rb_define_method(sr_mSiren, "sweep_path",      RUBY_METHOD_FUNC(siren_offset_sweep_path),      -1);
+  rb_define_method(sr_mSiren, "loft",            RUBY_METHOD_FUNC(siren_offset_loft),            -1);
+  rb_define_method(sr_mSiren, "offset_geomsurf", RUBY_METHOD_FUNC(siren_offset_offset_geomsurf), -1);
+  rb_define_method(sr_mSiren, "offset",          RUBY_METHOD_FUNC(siren_offset_offset),          -1);
+  rb_define_method(sr_mSiren, "offset_shape",    RUBY_METHOD_FUNC(siren_offset_offset_shape),    -1);
+  rb_define_method(sr_mSiren, "pipe",            RUBY_METHOD_FUNC(siren_offset_pipe),            -1);
+  return true;
+}
+
+VALUE siren_offset_sweep_vec(int argc, VALUE* argv, VALUE self)
+{
+  VALUE target, vec;
+  rb_scan_args(argc, argv, "2", &target, &vec);
+
+  TopoDS_Shape* profile = siren_shape_get(target);
+
+  gp_Pnt sp = gp_Pnt(0., 0., 0.).Transformed(profile->Location());
+  gp_Pnt tp = siren_ary_to_pnt(vec).Transformed(profile->Location());
+
+  TopoDS_Edge pe = BRepBuilderAPI_MakeEdge(sp, tp);
+  TopoDS_Wire path = BRepBuilderAPI_MakeWire(pe);
+
+  BRepOffsetAPI_MakePipe mp(path, *profile);
+  mp.Build();
+
+  return siren_shape_new(mp.Shape());
+}
+
+VALUE siren_offset_sweep_path(int argc, VALUE* argv, VALUE self)
+{
+  VALUE target, pathwire;
+  VALUE cont, corr;
+  VALUE scale_first, scale_last;
+  rb_scan_args(argc, argv, "24", &target, &pathwire, &cont, &corr, &scale_first, &scale_last);
+
+  TopoDS_Shape* shape_profile = siren_shape_get(target);
+  TopoDS_Shape* shape_path = siren_shape_get(pathwire);
+
+  TopoDS_Wire path;
+
+  if (shape_path->ShapeType() == TopAbs_EDGE) {
+    path = BRepBuilderAPI_MakeWire(TopoDS::Edge(*shape_path));
+  }
+  else if (shape_path->ShapeType() == TopAbs_WIRE) {
+    path = TopoDS::Wire(*shape_path);
+  }
+  else {
+    rb_raise(Qnil, "Type of path is not Edge or Wire.");
+  }
+
+  VALUE result = Qnil;
+
+  if (argc >= 3 && argc <= 6) {
+
+    Standard_Boolean withContact = (Standard_Boolean)cont;
+    Standard_Boolean withCorrection = (Standard_Boolean)corr;
+
+    BRepOffsetAPI_MakePipeShell ps(path);
+
+    // get params
+    Standard_Real fparam, lparam;
+    {
+      BRepAdaptor_CompCurve cc(path);
+      fparam = cc.FirstParameter();
+      lparam = cc.LastParameter();
+    }
+
+    if (argc < 6) {
+      scale_last  = 1.0;
+      if (argc < 5) {
+        scale_first = 1.0;
+      }
+    }
+
+    //opencascade::handle<Law_Linear> law = new Law_Linear();
+    //law->Set(fparam, scale_first, lparam, scale_last);
+
+    opencascade::handle<Law_S> law = new Law_S();
+    law->Set(fparam, scale_first, lparam, scale_last);
+
+    //opencascade::handle<Law_Composite> law = new Law_Composite(fparam, lparam, 1.0e-6);
+
+    // get start point
+    TopoDS_Vertex pfirst; {
+      TopoDS_Vertex plast;
+      TopExp::Vertices(path, pfirst, plast);
+    }
+
+    ps.SetLaw(
+        *shape_profile, // セクションプロファイル
+        law,           // 掃引規則
+        pfirst,        // 開始点
+        withContact,   // translate profile to start point
+        withCorrection // Change normal of profile by curveture
+        );
+
+    ps.Build();
+    result = siren_shape_new(ps.Shape());
+  }
+  else {
+    BRepOffsetAPI_MakePipe mp(path, *shape_profile);
+    mp.Build();
+    result = siren_shape_new(mp.Shape());
+  }
+  return result;
+}
+
+VALUE siren_offset_loft(int argc, VALUE* argv, VALUE self)
+{
+  VALUE objs;
+  VALUE smooth, is_solid, is_ruled;
+  rb_scan_args(argc, argv, "13", &objs, &smooth,  &is_solid, &is_ruled);
+  int lsize = RARRAY_LEN(objs);
+
+  if (lsize < 2) {
+    rb_raise(Qnil, "Number of shapes must be over 2 wires.");
+  }
+
+  Standard_Boolean is_sm, is_s, is_r;
+  is_sm = argc < 2 ? Standard_True : (Standard_Boolean)smooth;
+  is_s = argc < 3 ? Standard_False : (Standard_Boolean)is_solid;
+  is_r = argc < 4 ? Standard_True : (Standard_Boolean)is_ruled;
+
+  BRepOffsetAPI_ThruSections ts(is_s, is_r);
+
+  for (int i=0; i<lsize; i++) {
+    VALUE line = RARRAY_AREF(objs, i);
+    TopoDS_Shape* shape = siren_shape_get(line);
+    TopoDS_Wire w = TopoDS::Wire(*shape);
+    ts.AddWire(w);
+  }
+
+  ts.SetSmoothing(is_sm);
+  ts.Build();
+
+  return siren_shape_new(ts.Shape());
+}
+
+VALUE siren_offset_offset_geomsurf(int argc, VALUE* argv, VALUE self)
+{
+  VALUE target;
+  VALUE offset, tol;
+  rb_scan_args(argc, argv, "21", &target, &offset, &tol);
+  if (argc < 3)
+    tol = 1.0;
+
+  TopoDS_Shape* shape = siren_shape_get(target);
+
+  TopoDS_Compound comp;
+  BRep_Builder B;
+  B.MakeCompound(comp);
+
+  TopExp_Explorer exp(*shape, TopAbs_FACE);
+
+  for (; exp.More(); exp.Next()) {
+    TopoDS_Face face = TopoDS::Face(exp.Current());
+    opencascade::handle<Geom_Surface> gs = BRep_Tool::Surface(face);
+    opencascade::handle<Geom_OffsetSurface> gos = new Geom_OffsetSurface(gs, offset);
+    TopoDS_Face newface = BRepBuilderAPI_MakeFace(gos, tol);
+    B.Add(comp, newface);
+  }
+
+  return siren_shape_new(comp);
+}
+
+VALUE siren_offset_offset(int argc, VALUE* argv, VALUE self)
+{
+  VALUE target;
+  VALUE offset, tol;
+  VALUE mode = (int)BRepOffset_Skin;
+  VALUE intersect = false, self_intersect = false;
+  VALUE join = (int)GeomAbs_Arc;
+  VALUE thickening = false;
+  rb_scan_args(argc, argv, "35", &target, &offset, &tol, &mode,
+      &intersect, &self_intersect, &join, &thickening);
+
+  TopoDS_Shape* shape = siren_shape_get(target);
+
+  BRepOffset_MakeOffset api;
+  api.Initialize(*shape, offset, tol, (BRepOffset_Mode)mode,
+      intersect, self_intersect, (GeomAbs_JoinType)join, thickening);
+  api.MakeOffsetShape();
+  if (api.IsDone()) {
+    return siren_shape_new(api.Shape());
+  }
+  else {
+    switch (api.Error()) {
+    default: break;
+    }
+  }
+  return Qnil;
+}
+
+VALUE siren_offset_offset_shape(int argc, VALUE* argv, VALUE self)
+{
+  VALUE target;
+  VALUE offset, tol;
+  VALUE mode = (int)BRepOffset_Skin;
+  VALUE intersect = false, self_intersect = false;
+  VALUE join = (int)GeomAbs_Arc;
+  rb_scan_args(argc, argv, "34", &target, &offset, &tol, &mode,
+      &intersect, &self_intersect, &join);
+
+  TopoDS_Shape* shape = siren_shape_get(target);
+
+  TopoDS_Shape result = BRepOffsetAPI_MakeOffsetShape(*shape, offset, tol, (BRepOffset_Mode)mode,
+      intersect, self_intersect, (GeomAbs_JoinType)join);
+
+  return siren_shape_new(result);
+}
+
+VALUE siren_offset_pipe(int argc, VALUE* argv, VALUE self)
+{
+  VALUE profile, path;
+  VALUE mode;
+  VALUE force_approx_c1;
+  rb_scan_args(argc, argv, "22", &profile, &path, &mode, &force_approx_c1);
+
+  TopoDS_Shape* shape_profile = siren_shape_get(profile);
+  TopoDS_Shape* shape_path = siren_shape_get(path);
+
+  if (shape_path->ShapeType() != TopAbs_WIRE) {
+    rb_raise(Qnil, "Type of path is not Edge or Wire.");
+  }
+
+  TopoDS_Wire wire = TopoDS::Wire(*shape_path);
+
+  if (argc == 2) {
+    BRepOffsetAPI_MakePipe mp(wire, *shape_profile);
+    mp.Build();
+    return siren_shape_new(mp.Shape());
+  }
+  if (argc == 3) {
+    force_approx_c1 = Qfalse;
+  }
+
+  BRepOffsetAPI_MakePipe mp(wire, *shape_profile, (GeomFill_Trihedron)mode, force_approx_c1 == Qtrue);
+  mp.Build();
+  return siren_shape_new(mp.Shape());
+}

data/ext/siren2/src/shape.cpp

@@ -0,0 +1,617 @@
+/*
+ * Document-class: Shape
+ *
+ */
+
+#include "shape.h"
+
+VALUE sr_cShape;
+
+VALUE siren_shape_allocate(VALUE klass)
+{
+  void* p = ruby_xmalloc(sizeof(TopoDS_Shape));
+  new(p) TopoDS_Shape();
+  return Data_Wrap_Struct(klass, NULL, siren_shape_final, p);
+}
+
+TopoDS_Shape* siren_shape_get(VALUE obj)
+{
+  TopoDS_Shape* m;
+  Data_Get_Struct(obj, TopoDS_Shape, m);
+  return m;
+}
+
+VALUE siren_shape_new(const TopoDS_Shape& shape)
+{
+  VALUE klass;
+  switch (shape.ShapeType()) {
+    case TopAbs_VERTEX:    klass = sr_cVertex;    break;
+    case TopAbs_EDGE:      klass = sr_cEdge;      break;
+    case TopAbs_WIRE:      klass = sr_cWire;      break;
+    case TopAbs_FACE:      klass = sr_cFace;      break;
+    case TopAbs_SHELL:     klass = sr_cShell;     break;
+    case TopAbs_SOLID:     klass = sr_cSolid;     break;
+#ifdef SR_ENABLE_CHUNK
+    case TopAbs_COMPSOLID: klass = sr_cCompSolid; break;
+#endif
+    case TopAbs_COMPOUND:  klass = sr_cCompound;  break;
+    default:
+      rb_raise(Qnil, "Failed to make Shape object.");
+      break;
+  }
+  auto val = siren_shape_allocate(klass);
+  auto ps = siren_shape_get(val);
+  *ps = shape;
+  return val;
+}
+
+bool siren_shape_install()
+{
+  sr_cShape = rb_define_class_under(sr_mSiren, "Shape", rb_cObject);
+  rb_define_alloc_func(sr_cShape, siren_shape_allocate);
+  rb_define_method(sr_cShape, "initialize", RUBY_METHOD_FUNC(siren_shape_init),           -1);
+  rb_define_method(sr_cShape, "null?",      RUBY_METHOD_FUNC(siren_shape_is_null),        -1);
+  rb_define_method(sr_cShape, "pos",        RUBY_METHOD_FUNC(siren_shape_pos),            -1);
+  rb_define_method(sr_cShape, "trans",      RUBY_METHOD_FUNC(siren_shape_trans),          -1);
+  rb_define_method(sr_cShape, "trans=",     RUBY_METHOD_FUNC(siren_shape_set_trans),      -1);
+  rb_define_method(sr_cShape, "bndbox",     RUBY_METHOD_FUNC(siren_shape_bndbox),         -1);
+  rb_define_method(sr_cShape, "translate!", RUBY_METHOD_FUNC(siren_shape_translate_bang), -1);
+  rb_define_method(sr_cShape, "rotate!",    RUBY_METHOD_FUNC(siren_shape_rotate_bang),    -1);
+  rb_define_method(sr_cShape, "scale!",     RUBY_METHOD_FUNC(siren_shape_scale_bang),     -1);
+  rb_define_method(sr_cShape, "mirror!",    RUBY_METHOD_FUNC(siren_shape_mirror_bang),    -1);
+  rb_define_method(sr_cShape, "move!",      RUBY_METHOD_FUNC(siren_shape_move_bang),      -1);
+  rb_define_method(sr_cShape, "translate",  RUBY_METHOD_FUNC(siren_shape_translate),      -1);
+  rb_define_method(sr_cShape, "rotate",     RUBY_METHOD_FUNC(siren_shape_rotate),         -1);
+  rb_define_method(sr_cShape, "scale",      RUBY_METHOD_FUNC(siren_shape_scale),          -1);
+  rb_define_method(sr_cShape, "mirror",     RUBY_METHOD_FUNC(siren_shape_mirror),         -1);
+  rb_define_method(sr_cShape, "move",       RUBY_METHOD_FUNC(siren_shape_move),           -1);
+  rb_define_method(sr_cShape, "hashcode",   RUBY_METHOD_FUNC(siren_shape_hashcode),       -1);
+  rb_define_method(sr_cShape, "partner?",   RUBY_METHOD_FUNC(siren_shape_is_partner),     -1);
+  rb_define_method(sr_cShape, "same?",      RUBY_METHOD_FUNC(siren_shape_is_same),        -1);
+  rb_define_method(sr_cShape, "equal?",     RUBY_METHOD_FUNC(siren_shape_is_equal),       -1);
+  rb_define_method(sr_cShape, "<=>",        RUBY_METHOD_FUNC(siren_shape_is_equal),       -1);
+  rb_define_method(sr_cShape, "explore",    RUBY_METHOD_FUNC(siren_shape_explore),        -1);
+  rb_define_method(sr_cShape, "subshapes",  RUBY_METHOD_FUNC(siren_shape_subshapes),      -1);
+  rb_define_method(sr_cShape, "section",    RUBY_METHOD_FUNC(siren_shape_section),        -1);
+  rb_define_method(sr_cShape, "reverse",    RUBY_METHOD_FUNC(siren_shape_reverse),        -1);
+  rb_define_method(sr_cShape, "reverse!",   RUBY_METHOD_FUNC(siren_shape_reverse_bang),   -1);
+#ifdef SR_ENABLE_SHHEALING
+  rb_define_method(sr_cShape, "outerwire",  RUBY_METHOD_FUNC(siren_heal_outerwire),       -1);
+  rb_define_method(sr_cShape, "fix",        RUBY_METHOD_FUNC(siren_heal_fix),             -1);
+#endif
+  /* from BRepTools */
+  rb_define_method(sr_cShape, "update!",    RUBY_METHOD_FUNC(siren_shape_update_bang),     -1);
+  rb_define_method(sr_cShape, "clean!",     RUBY_METHOD_FUNC(siren_shape_clean_bang),      -1);
+  /* frag accessors */
+  rb_define_method(sr_cShape, "lock?",       RUBY_METHOD_FUNC(siren_shape_is_lock),        -1);
+  rb_define_method(sr_cShape, "lock",        RUBY_METHOD_FUNC(siren_shape_is_lock),        -1);
+  rb_define_method(sr_cShape, "lock=",       RUBY_METHOD_FUNC(siren_shape_set_lock),       -1);
+  rb_define_method(sr_cShape, "modify?",     RUBY_METHOD_FUNC(siren_shape_is_modify),      -1);
+  rb_define_method(sr_cShape, "modify",      RUBY_METHOD_FUNC(siren_shape_is_modify),      -1);
+  rb_define_method(sr_cShape, "modify=",     RUBY_METHOD_FUNC(siren_shape_set_modify),     -1);
+  rb_define_method(sr_cShape, "check?",      RUBY_METHOD_FUNC(siren_shape_is_check),       -1);
+  rb_define_method(sr_cShape, "check",       RUBY_METHOD_FUNC(siren_shape_is_check),       -1);
+  rb_define_method(sr_cShape, "check=",      RUBY_METHOD_FUNC(siren_shape_set_check),      -1);
+  rb_define_method(sr_cShape, "orientable?", RUBY_METHOD_FUNC(siren_shape_is_orientable),  -1);
+  rb_define_method(sr_cShape, "orientable",  RUBY_METHOD_FUNC(siren_shape_is_orientable),  -1);
+  rb_define_method(sr_cShape, "orientable=", RUBY_METHOD_FUNC(siren_shape_set_orientable), -1);
+  rb_define_method(sr_cShape, "close?",      RUBY_METHOD_FUNC(siren_shape_is_close),       -1);
+  rb_define_method(sr_cShape, "close",       RUBY_METHOD_FUNC(siren_shape_is_close),       -1);
+  rb_define_method(sr_cShape, "close=",      RUBY_METHOD_FUNC(siren_shape_set_close),      -1);
+  rb_define_method(sr_cShape, "infinite?",   RUBY_METHOD_FUNC(siren_shape_is_infinite),    -1);
+  rb_define_method(sr_cShape, "infinite",    RUBY_METHOD_FUNC(siren_shape_is_infinite),    -1);
+  rb_define_method(sr_cShape, "infinite=",   RUBY_METHOD_FUNC(siren_shape_set_infinite),   -1);
+  rb_define_method(sr_cShape, "convex?",     RUBY_METHOD_FUNC(siren_shape_is_convex),      -1);
+  rb_define_method(sr_cShape, "convex",      RUBY_METHOD_FUNC(siren_shape_is_convex),      -1);
+  rb_define_method(sr_cShape, "convex=",     RUBY_METHOD_FUNC(siren_shape_set_convex),     -1);
+  rb_define_method(sr_cShape, "next_trans",  RUBY_METHOD_FUNC(siren_shape_next_trans),     -1);
+  rb_define_method(sr_cShape, "first_datum", RUBY_METHOD_FUNC(siren_shape_first_datum),    -1);
+
+  siren_vertex_install();
+  siren_edge_install();
+  siren_wire_install();
+  siren_face_install();
+  siren_shell_install();
+  siren_solid_install();
+#ifdef SR_ENABLE_CHUNK
+  siren_chunk_install();
+#endif
+  siren_compound_install();
+
+  return true;
+}
+
+VALUE siren_shape_init(int argc, VALUE* argv, VALUE self)
+{
+  rb_raise(rb_eNoMethodError, "private method `new' called for Shape:Class");
+  return Qnil;
+}
+
+void siren_shape_final( void* p)
+{
+  TopoDS_Shape* s = static_cast<TopoDS_Shape*>(p);
+  s->Nullify();
+  ruby_xfree(s);
+}
+
+VALUE siren_shape_is_null(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  return shape->IsNull() ? Qtrue : Qfalse;
+}
+
+VALUE siren_shape_pos(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  gp_XYZ pos = shape->Location().Transformation().TranslationPart();
+  return siren_pnt_to_ary(gp_Pnt(pos.X(), pos.Y(), pos.Z()));
+}
+
+VALUE siren_shape_trans(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  TopLoc_Location loc = shape->Location();
+  return siren_trans_new(loc.Transformation());
+}
+
+VALUE siren_shape_next_trans(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  TopLoc_Location loc = shape->Location().NextLocation();
+  return siren_trans_new(loc.Transformation());
+}
+
+VALUE siren_shape_first_datum(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  TopLoc_Location loc = shape->Location();
+  opencascade::handle<TopLoc_Datum3D> datum = loc.FirstDatum();
+  gp_Trsf t = datum->Transformation();
+  return siren_trans_new(t);
+}
+
+VALUE siren_shape_set_trans(int argc, VALUE* argv, VALUE self)
+{
+  VALUE obj;
+  rb_scan_args(argc, argv, "1", &obj);
+  gp_Trsf* trans = siren_trans_get(obj);
+  TopLoc_Location loc(*trans);
+  siren_shape_get(self)->Location(loc);
+  return self;
+}
+
+VALUE siren_shape_bndbox(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  return siren_bndbox_new(*shape);
+}
+
+VALUE siren_shape_translate_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE vec;
+  rb_scan_args(argc, argv, "1", &vec);
+  gp_Trsf trsf;
+  trsf.SetTranslation(siren_ary_to_vec(vec));
+  siren_shape_get(self)->Move(trsf);
+  return self;
+}
+
+VALUE siren_shape_rotate_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op, norm;
+  VALUE ang;
+  rb_scan_args(argc, argv, "3", &op, &norm, &ang);
+  gp_Trsf trsf;
+  trsf.SetRotation(siren_ary_to_ax1(op, norm), ang);
+  siren_shape_get(self)->Move(trsf);
+  return self;
+}
+
+VALUE siren_shape_scale_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op;
+  VALUE factor;
+  rb_scan_args(argc, argv, "2", &op, &factor);
+  gp_Trsf trsf;
+  trsf.SetScale(siren_ary_to_pnt(op), factor);
+  siren_shape_get(self)->Move(trsf);
+  return self;
+}
+
+VALUE siren_shape_mirror_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op, norm;
+  rb_scan_args(argc, argv, "2", &op, &norm);
+  gp_Trsf trsf;
+  trsf.SetMirror(siren_ary_to_ax2(op, norm));
+  siren_shape_get(self)->Move(trsf);
+  return self;
+}
+
+VALUE siren_shape_move_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE trans;
+  rb_scan_args(argc, argv, "1", &trans);
+  gp_Trsf* t = siren_trans_get(trans);
+  siren_shape_get(self)->Move(*t);
+  return self;
+}
+
+VALUE siren_shape_translate(int argc, VALUE* argv, VALUE self)
+{
+  VALUE vec;
+  rb_scan_args(argc, argv, "1", &vec);
+  gp_Trsf trsf;
+  trsf.SetTranslation(siren_ary_to_vec(vec));
+  return siren_shape_new(siren_shape_get(self)->Moved(trsf));
+}
+
+VALUE siren_shape_rotate(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op, norm;
+  VALUE ang;
+  rb_scan_args(argc, argv, "3", &op, &norm, &ang);
+  gp_Trsf trsf;
+  trsf.SetRotation(siren_ary_to_ax1(op, norm), ang);
+  return siren_shape_new(siren_shape_get(self)->Moved(trsf));
+}
+
+VALUE siren_shape_scale(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op;
+  VALUE factor;
+  rb_scan_args(argc, argv, "2", &op, &factor);
+  gp_Trsf trsf;
+  trsf.SetScale(siren_ary_to_pnt(op), factor);
+  return siren_shape_new(siren_shape_get(self)->Moved(trsf));
+}
+
+VALUE siren_shape_mirror(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op, norm;
+  rb_scan_args(argc, argv, "2", &op, &norm);
+  gp_Trsf trsf;
+  trsf.SetMirror(siren_ary_to_ax2(op, norm));
+  return siren_shape_new(siren_shape_get(self)->Moved(trsf));
+}
+
+VALUE siren_shape_move(int argc, VALUE* argv, VALUE self)
+{
+  VALUE trans;
+  rb_scan_args(argc, argv, "1", &trans);
+  gp_Trsf* t = siren_trans_get(trans);
+  return siren_shape_new(siren_shape_get(self)->Moved(*t));
+}
+
+VALUE siren_shape_hashcode(int argc, VALUE* argv, VALUE self)
+{
+  VALUE upper;
+  rb_scan_args(argc, argv, "1", &upper);
+  TopoDS_Shape* shape = siren_shape_get(self);
+  return INT2FIX(shape->HashCode(upper));
+}
+
+VALUE siren_shape_is_partner(int argc, VALUE* argv, VALUE self)
+{
+  VALUE other;
+  rb_scan_args(argc, argv, "1", &other);
+  TopoDS_Shape* shape_self  = siren_shape_get(self);
+  TopoDS_Shape* shape_other = siren_shape_get(other);
+  return shape_self->IsPartner(*shape_other) ? Qtrue : Qfalse;
+}
+
+VALUE siren_shape_is_same(int argc, VALUE* argv, VALUE self)
+{
+  VALUE other;
+  rb_scan_args(argc, argv, "1", &other);
+  TopoDS_Shape* shape_self  = siren_shape_get(self);
+  TopoDS_Shape* shape_other = siren_shape_get(other);
+  return shape_self->IsSame(*shape_other) ? Qtrue : Qfalse;
+}
+
+VALUE siren_shape_is_equal(int argc, VALUE* argv, VALUE self)
+{
+  VALUE other;
+  rb_scan_args(argc, argv, "1", &other);
+  TopoDS_Shape* shape_self  = siren_shape_get(self);
+  TopoDS_Shape* shape_other = siren_shape_get(other);
+  return shape_self->IsEqual(*shape_other) ? Qtrue : Qfalse;
+}
+
+VALUE siren_shape_explore(int argc, VALUE* argv, VALUE self)
+{
+  VALUE klass;
+  VALUE klassf;
+  VALUE block;
+  rb_scan_args(argc, argv, "12", &klass, &klassf, &block);
+
+  VALUE mtype;
+  TopAbs_ShapeEnum type = TopAbs_COMPOUND;
+  if (rb_funcall(klass, rb_intern("=="), 1, sr_cCompound) == Qtrue) {
+    type = TopAbs_COMPOUND;
+  }
+#ifdef SR_ENABLE_CHUNK
+  else if (rb_funcall(klass, rb_intern("=="), 1, sr_cChunk) == Qtrue) {
+    type = TopAbs_COMPSOLID;
+  }
+#endif
+  else if (rb_funcall(klass, rb_intern("=="), 1, sr_cSolid) == Qtrue) {
+    type = TopAbs_SOLID;
+  }
+  else if (rb_funcall(klass, rb_intern("=="), 1, sr_cShell) == Qtrue) {
+    type = TopAbs_SHELL;
+  }
+  else if (rb_funcall(klass, rb_intern("=="), 1, sr_cFace) == Qtrue) {
+    type = TopAbs_FACE;
+  }
+  else if (rb_funcall(klass, rb_intern("=="), 1, sr_cWire) == Qtrue) {
+    type = TopAbs_WIRE;
+  }
+  else if (rb_funcall(klass, rb_intern("=="), 1, sr_cEdge) == Qtrue) {
+    type = TopAbs_EDGE;
+  }
+  else if (rb_funcall(klass, rb_intern("=="), 1, sr_cVertex) == Qtrue) {
+    type = TopAbs_VERTEX;
+  }
+  else {
+    rb_raise(Qnil, "Type error.");
+  }
+
+  TopExp_Explorer ex;
+  if (argc == 1) {
+    ex.Init(*siren_shape_get(self), type);
+  }
+  else {
+    VALUE mfilter;
+    TopAbs_ShapeEnum avoid = TopAbs_COMPOUND;
+    if (rb_funcall(klassf, rb_intern("=="), 1, sr_cCompound) == Qtrue) {
+      avoid = TopAbs_COMPOUND;
+    }
+#ifdef SR_ENABLE_CHUNK
+    else if (rb_funcall(klassf, rb_intern("=="), 1, sr_cChunk) == Qtrue) {
+      avoid = TopAbs_COMPSOLID;
+    }
+#endif
+    else if (rb_funcall(klassf, rb_intern("=="), 1, sr_cSolid) == Qtrue) {
+      avoid = TopAbs_SOLID;
+    }
+    else if (rb_funcall(klassf, rb_intern("=="), 1, sr_cShell) == Qtrue) {
+      avoid = TopAbs_SHELL;
+    }
+    else if (rb_funcall(klassf, rb_intern("=="), 1, sr_cFace) == Qtrue) {
+      avoid = TopAbs_FACE;
+    }
+    else if (rb_funcall(klassf, rb_intern("=="), 1, sr_cWire) == Qtrue) {
+      avoid = TopAbs_WIRE;
+    }
+    else if (rb_funcall(klassf, rb_intern("=="), 1, sr_cEdge) == Qtrue) {
+      avoid = TopAbs_EDGE;
+    }
+    else if (rb_funcall(klassf, rb_intern("=="), 1, sr_cVertex) == Qtrue) {
+      avoid = TopAbs_VERTEX;
+    }
+    else {
+      rb_raise(Qnil, "Type error.");
+    }
+    ex.Init(*siren_shape_get(self), type, avoid);
+  }
+
+  if (!NIL_P(block)) {
+    for (; ex.More(); ex.Next()) {
+      VALUE argv[2];
+      argv[0] = siren_shape_new(ex.Current());
+      argv[1] = INT2FIX(ex.Depth());
+#if 0
+      rb_yield_argv(block, 2, argv);
+#else
+      // where is a block?
+      rb_yield_values2(2, argv);
+#endif
+    }
+    return self;
+  }
+  VALUE ar = rb_ary_new();
+  for (; ex.More(); ex.Next()) {
+#if 0
+    VALUE ai = rb_gc_arena_save();
+#endif
+    rb_ary_push(ar, siren_shape_new(ex.Current()));
+#if 0
+    rb_gc_arena_restore(ai);
+#endif
+  }
+  return ar;
+}
+
+VALUE siren_shape_subshapes(int argc, VALUE* argv, VALUE self)
+{
+  VALUE ori, loc;
+  rb_scan_args(argc, argv, "02", &ori, &loc);
+  if (argc == 0) {
+    ori = Qtrue;
+    loc = Qtrue;
+  }
+  if (argc == 1) {
+    loc = Qtrue;
+  }
+  VALUE ar = rb_ary_new();
+  TopoDS_Shape* shape = siren_shape_get(self);
+  if (!shape || shape->IsNull()) {
+    return ar;
+  }
+  TopoDS_Iterator it(*shape, ori == Qtrue, loc == Qtrue);
+  for (; it.More(); it.Next()) {
+#if 0
+    VALUE ai = rb_gc_arena_save();
+#endif
+    rb_ary_push(ar, siren_shape_new(it.Value()));
+#if 0
+    rb_gc_arena_restore(ai);
+#endif
+  }
+  return ar;
+}
+
+VALUE siren_shape_section(int argc, VALUE* argv, VALUE self)
+{
+  VALUE other;
+  rb_scan_args(argc, argv, "1", &other);
+
+  TopoDS_Shape* S1 = siren_shape_get(self);
+  TopoDS_Shape* S2 = siren_shape_get(other);
+
+  BRepAlgoAPI_Section api(*S1, *S2, Standard_False);
+  // api.ComputePCurveOn1(Standard_True);
+  api.Approximation(Standard_True);
+  api.Build();
+
+  if (!api.IsDone()) {
+    rb_raise(Qnil, "Failed to intersection.");
+  }
+
+  return siren_shape_new(api.Shape());
+}
+
+VALUE siren_shape_reverse(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  return siren_shape_new(shape->Reversed());
+}
+
+VALUE siren_shape_reverse_bang(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  shape->Reverse();
+  return Qnil;
+}
+
+VALUE siren_shape_update_bang(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  BRepTools::Update(*shape);
+  return self;
+}
+
+VALUE siren_shape_clean_bang(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  // Removes all the triangulations of the faces of <shape>
+  // and removes all polygons on triangulations of the edges.
+  BRepTools::Clean(*shape);
+  return self;
+}
+
+VALUE siren_shape_is_lock(int argc, VALUE* argv, VALUE self)
+{
+  return siren_shape_get(self)->Locked() == Standard_True ?
+    Qtrue : Qfalse;
+}
+
+VALUE siren_shape_set_lock(int argc, VALUE* argv, VALUE self)
+{
+  VALUE flag;
+  rb_scan_args(argc, argv, "1", &flag);
+  siren_shape_get(self)->Locked((Standard_Boolean)(flag == Qtrue));
+  return self;
+}
+
+VALUE siren_shape_is_modify(int argc, VALUE* argv, VALUE self)
+{
+  return siren_shape_get(self)->Modified() == Standard_True ?
+    Qtrue : Qfalse;
+}
+
+VALUE siren_shape_set_modify(int argc, VALUE* argv, VALUE self)
+{
+  VALUE flag;
+  rb_scan_args(argc, argv, "1", &flag);
+  siren_shape_get(self)->Modified((Standard_Boolean)(flag == Qtrue));
+  return self;
+}
+
+VALUE siren_shape_is_check(int argc, VALUE* argv, VALUE self)
+{
+  return siren_shape_get(self)->Checked() == Standard_True ?
+    Qtrue : Qfalse;
+}
+
+VALUE siren_shape_set_check(int argc, VALUE* argv, VALUE self)
+{
+  VALUE flag;
+  rb_scan_args(argc, argv, "1", &flag);
+  siren_shape_get(self)->Checked((Standard_Boolean)(flag == Qtrue));
+  return self;
+}
+
+VALUE siren_shape_is_orientable(int argc, VALUE* argv, VALUE self)
+{
+  return siren_shape_get(self)->Orientable() == Standard_True ?
+    Qtrue : Qfalse;
+}
+
+VALUE siren_shape_set_orientable(int argc, VALUE* argv, VALUE self)
+{
+  VALUE flag;
+  rb_scan_args(argc, argv, "1", &flag);
+  siren_shape_get(self)->Orientable((Standard_Boolean)(flag == Qtrue));
+  return self;
+}
+
+VALUE siren_shape_is_close(int argc, VALUE* argv, VALUE self)
+{
+  return siren_shape_get(self)->Closed() == Standard_True ?
+    Qtrue : Qfalse;
+}
+
+VALUE siren_shape_set_close(int argc, VALUE* argv, VALUE self)
+{
+  VALUE flag;
+  rb_scan_args(argc, argv, "1", &flag);
+  siren_shape_get(self)->Closed((Standard_Boolean)(flag == Qtrue));
+  return self;
+}
+
+VALUE siren_shape_is_infinite(int argc, VALUE* argv, VALUE self)
+{
+  return siren_shape_get(self)->Infinite() == Standard_True ?
+    Qtrue : Qfalse;
+}
+
+VALUE siren_shape_set_infinite(int argc, VALUE* argv, VALUE self)
+{
+  VALUE flag;
+  rb_scan_args(argc, argv, "1", &flag);
+  siren_shape_get(self)->Infinite((Standard_Boolean)(flag == Qtrue));
+  return self;
+}
+
+VALUE siren_shape_is_convex(int argc, VALUE* argv, VALUE self)
+{
+  return siren_shape_get(self)->Convex() == Standard_True ?
+    Qtrue : Qfalse;
+}
+
+VALUE siren_shape_set_convex(int argc, VALUE* argv, VALUE self)
+{
+  VALUE flag;
+  rb_scan_args(argc, argv, "1", &flag);
+  siren_shape_get(self)->Convex((Standard_Boolean)(flag == Qtrue));
+  return self;
+}
+
+bool siren_shape_p(const VALUE& target)
+{
+  return rb_funcall(target, rb_intern("is_a?"), 1, sr_cShape) == Qtrue;
+}
+
+void siren_shape_check(const VALUE& target)
+{
+  if (!siren_shape_p(target)) {
+    VALUE type = rb_funcall(target, rb_intern("class"), 0);
+    VALUE type_str = rb_funcall(type, rb_intern("to_s"), 0);
+    VALUE etype_str = rb_funcall(sr_cShape, rb_intern("to_s"), 0);
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
+        RSTRING_PTR(type_str), RSTRING_PTR(etype_str));
+  }
+}
+