siren2 0.1.2

data/ext/siren2/src/siren.cpp

@@ -0,0 +1,80 @@
+#include "siren.h"
+
+#include "vec.h"
+#include "trans.h"
+#include "bndbox.h"
+#include "shape.h"
+#include "brep.h"
+#include "topalgo.h"
+#include "curve.h"
+#include "filler.h"
+
+#ifdef SR_ENABLE_BO
+  #include "bo.h"
+#endif
+
+#ifdef SR_ENABLE_SHHEALING
+  #include "heal.h"
+#endif
+
+#ifdef SR_ENABLE_OFFSET
+  #include "offset.h"
+#endif
+
+#ifdef SR_ENABLE_IGES
+  #include "io/iges.h"
+#endif
+
+#ifdef SR_ENABLE_STL
+  #include "io/stl.h"
+#endif
+
+#ifdef SR_ENABLE_STEP
+  #include "io/step.h"
+#endif
+
+VALUE sr_mSiren;
+
+extern "C" {
+
+  // initializer
+  void Init_siren2()
+  {
+    // Siren module
+    sr_mSiren  = rb_define_module("Siren");
+
+    // Class
+    siren_vec_install    ();
+    siren_trans_install  ();
+    siren_bndbox_install ();
+    siren_shape_install  ();
+    siren_curve_install  ();
+    siren_topalgo_install();
+    siren_brep_install   ();
+    siren_filler_install ();
+#ifdef SR_ENABLE_OFFSET
+    siren_offset_install ();
+#endif
+#ifdef SR_ENABLE_BO
+    siren_bo_install     ();
+#endif
+#ifdef SR_ENABLE_IGES
+    siren_iges_install   ();
+#endif
+#ifdef SR_ENABLE_STL
+    siren_stl_install    ();
+#endif
+#ifdef SR_ENABLE_STEP
+    siren_step_install   ();
+#endif
+
+    return;
+  }
+
+  // finalizer
+  void rb_mruby_siren_gem_final()
+  {
+    return;
+  }
+
+} // extern "C" {

data/ext/siren2/src/topalgo.cpp

@@ -0,0 +1,246 @@
+#include "topalgo.h"
+
+bool siren_topalgo_install()
+{
+  // Class method
+#if 0
+  rb_define_class_method(sr_mSiren, "copy",       RUBY_METHOD_FUNC(siren_topalgo_copy),        -1);
+  rb_define_class_method(sr_mSiren, "line",       RUBY_METHOD_FUNC(siren_topalgo_line),        -1);
+  rb_define_class_method(sr_mSiren, "infline",    RUBY_METHOD_FUNC(siren_topalgo_infline),     -1);
+  rb_define_class_method(sr_mSiren, "polyline",   RUBY_METHOD_FUNC(siren_topalgo_polyline),    -1);
+  rb_define_class_method(sr_mSiren, "interpolate",RUBY_METHOD_FUNC(siren_topalgo_interpolate), -1);
+  rb_define_class_method(sr_mSiren, "arc",        RUBY_METHOD_FUNC(siren_topalgo_arc),         -1);
+  rb_define_class_method(sr_mSiren, "arc3p",      RUBY_METHOD_FUNC(siren_topalgo_arc3p),       -1);
+  rb_define_class_method(sr_mSiren, "circle",     RUBY_METHOD_FUNC(siren_topalgo_circle),      -1);
+  rb_define_class_method(sr_mSiren, "circle3p",   RUBY_METHOD_FUNC(siren_topalgo_circle3p),    -1);
+#endif
+  // For mix-in
+  rb_define_method(sr_mSiren, "copy",        RUBY_METHOD_FUNC(siren_topalgo_copy),        -1);
+  rb_define_method(sr_mSiren, "line",        RUBY_METHOD_FUNC(siren_topalgo_line),        -1);
+  rb_define_method(sr_mSiren, "infline",     RUBY_METHOD_FUNC(siren_topalgo_infline),     -1);
+  rb_define_method(sr_mSiren, "polyline",    RUBY_METHOD_FUNC(siren_topalgo_polyline),    -1);
+  rb_define_method(sr_mSiren, "interpolate", RUBY_METHOD_FUNC(siren_topalgo_interpolate), -1);
+  rb_define_method(sr_mSiren, "arc",         RUBY_METHOD_FUNC(siren_topalgo_arc),         -1);
+  rb_define_method(sr_mSiren, "arc3p",       RUBY_METHOD_FUNC(siren_topalgo_arc3p),       -1);
+  rb_define_method(sr_mSiren, "circle",      RUBY_METHOD_FUNC(siren_topalgo_circle),      -1);
+  rb_define_method(sr_mSiren, "circle3p",    RUBY_METHOD_FUNC(siren_topalgo_circle3p),    -1);
+  rb_define_method(sr_cShape, "cog",         RUBY_METHOD_FUNC(siren_topalgo_cog),         -1);
+  rb_define_method(sr_cShape, "area",        RUBY_METHOD_FUNC(siren_topalgo_area),        -1);
+  rb_define_method(sr_cShape, "volume",      RUBY_METHOD_FUNC(siren_topalgo_volume),      -1);
+
+  return true;
+}
+
+VALUE siren_topalgo_copy(int argc, VALUE* argv, VALUE self)
+{
+  VALUE target;
+  VALUE copy_geom = Standard_True;
+
+  rb_scan_args(argc, argv, "11", &target, &copy_geom);
+
+  TopoDS_Shape* src = siren_shape_get(target);
+  TopoDS_Shape res = BRepBuilderAPI_Copy(*src, (Standard_Boolean)copy_geom);
+  return siren_shape_new(res);
+}
+
+VALUE siren_topalgo_line(int argc, VALUE* argv, VALUE self)
+{
+  VALUE sp, tp;
+  rb_scan_args(argc, argv, "02", &sp, &tp);
+  gp_Pnt S(0., 0., 0.);
+  gp_Pnt T(1., 1., 1.);
+  if (argc > 0) {
+    S = siren_ary_to_pnt(sp);
+  }
+  if (argc > 1) {
+    T = siren_ary_to_pnt(tp);
+  }
+  Standard_Real linear_tolerance = 1.0e-7;
+  if (S.IsEqual(T, linear_tolerance)) {
+    rb_raise(Qnil,
+        "Specified terminal point same as the start point.");
+  }
+  TopoDS_Shape shape = BRepBuilderAPI_MakeEdge(S, T);
+  return siren_shape_new(shape);
+}
+
+VALUE siren_topalgo_infline(int argc, VALUE* argv, VALUE self)
+{
+  VALUE orig, dir;
+  rb_scan_args(argc, argv, "02", &orig, &dir);
+  gp_Pnt p(0., 0., 0.);
+  gp_Dir d(1., 0., 0.);
+  if (argc > 0) {
+    p = siren_ary_to_pnt(orig);
+  }
+  if (argc > 1) {
+    d = siren_ary_to_dir(dir);
+  }
+  TopoDS_Shape shape = BRepBuilderAPI_MakeEdge(gp_Lin(p, d));
+  return siren_shape_new(shape);
+}
+
+VALUE siren_topalgo_polyline(int argc, VALUE* argv, VALUE self)
+{
+  VALUE ary;
+  rb_scan_args(argc, argv, "1", &ary);
+  BRepBuilderAPI_MakePolygon poly;
+  for (int i = 0; i < RARRAY_LEN(ary); i++) {
+    poly.Add(siren_ary_to_pnt(RARRAY_AREF(ary, i)));
+  }
+  TopoDS_Shape shape = poly.Wire();
+  return siren_shape_new(shape);
+}
+
+VALUE siren_topalgo_interpolate(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pts, vecs;
+  rb_scan_args(argc, argv, "11", &pts, &vecs);
+
+  int psize = RARRAY_LEN(pts);
+  opencascade::handle<TColgp_HArray1OfPnt> pary = new TColgp_HArray1OfPnt(1, psize);
+  for (int i=0; i<psize; i++) {
+    pary->SetValue(i+1, siren_ary_to_pnt(RARRAY_AREF(pts, i)));
+  }
+
+  try {
+    Standard_Real tolerance = 1.0e-7;
+    Standard_Boolean periodic_flag = Standard_False;
+
+    // Raise exception when got pary has same points.
+    GeomAPI_Interpolate intp(pary, periodic_flag, tolerance);
+
+    if (argc == 2) {
+      TColgp_Array1OfVec vec(1, psize);
+      opencascade::handle<TColStd_HArray1OfBoolean> use = new TColStd_HArray1OfBoolean(1, psize);
+
+      for (int i=0; i<psize; i++) {
+        VALUE avec = RARRAY_AREF(vecs, i);
+        if (NIL_P(avec)) {
+          use->SetValue(i+1, Standard_False);
+        }
+        else {
+          vec.SetValue(i+1, siren_ary_to_vec(avec));
+          use->SetValue(i+1, Standard_True);
+        }
+      }
+      intp.Load(vec, use, Standard_True);
+    }
+
+    intp.Perform();
+    if (!intp.IsDone()) {
+      rb_raise(Qnil, "Failed to make a curve.");
+    }
+
+    opencascade::handle<Geom_BSplineCurve> geSpl = intp.Curve();
+    if (geSpl.IsNull()) {
+      rb_raise(Qnil, "Failed to make a curve.");
+    }
+
+    TopoDS_Shape shape = BRepBuilderAPI_MakeEdge(geSpl);
+    return siren_shape_new(shape);
+  }
+  catch (...) {
+    rb_raise(Qnil, "Failed to make a curve. Incorrect points specified.");
+  }
+  return Qnil;
+}
+
+VALUE siren_topalgo_arc(int argc, VALUE* argv, VALUE self)
+{
+  VALUE orig, dir, vx;
+  VALUE r, start_ang, term_ang;
+  rb_scan_args(argc, argv, "6", &orig, &dir, &vx, &r, &start_ang, &term_ang);
+  gp_Circ circle = gp_Circ(gp_Ax2(siren_ary_to_pnt(orig), siren_ary_to_dir(dir), siren_ary_to_dir(vx)), NUM2DBL(r));
+  opencascade::handle<Geom_TrimmedCurve> gc = GC_MakeArcOfCircle(circle, NUM2DBL(start_ang), NUM2DBL(term_ang), Standard_True);
+  if (gc.IsNull()) {
+    rb_raise(Qnil, "Failed to make a curve.");
+    return Qnil;
+  }
+  else {
+    TopoDS_Edge E = BRepBuilderAPI_MakeEdge(gc);
+    return siren_shape_new(E);
+  }
+}
+
+VALUE siren_topalgo_arc3p(int argc, VALUE* argv, VALUE self)
+{
+  VALUE p1, p2, p3;
+  rb_scan_args(argc, argv, "3", &p1, &p2, &p3);
+  opencascade::handle<Geom_TrimmedCurve> gc = GC_MakeArcOfCircle(
+      siren_ary_to_pnt(p1),
+      siren_ary_to_pnt(p2),
+      siren_ary_to_pnt(p3));
+  if (gc.IsNull()) {
+    rb_raise(Qnil, "Failed to make a curve.");
+    return Qnil;
+  }
+  else {
+    TopoDS_Edge E = BRepBuilderAPI_MakeEdge(gc);
+    return siren_shape_new(E);
+  }
+}
+
+VALUE siren_topalgo_circle(int argc, VALUE* argv, VALUE self)
+{
+  VALUE orig, dir;
+  VALUE r;
+  rb_scan_args(argc, argv, "3", &orig, &dir, &r);
+  opencascade::handle<Geom_Circle> gc = GC_MakeCircle(
+      siren_ary_to_pnt(orig),
+      siren_ary_to_dir(dir),
+      NUM2DBL(r));
+  if (gc.IsNull()) {
+    rb_raise(Qnil, "Failed to make a curve.");
+    return Qnil;
+  }
+  else {
+    TopoDS_Edge E = BRepBuilderAPI_MakeEdge(gc);
+    return siren_shape_new(E);
+  }
+}
+
+VALUE siren_topalgo_circle3p(int argc, VALUE* argv, VALUE self)
+{
+  VALUE p1, p2, p3;
+  rb_scan_args(argc, argv, "3", &p1, &p2, &p3);
+  opencascade::handle<Geom_Circle> gc = GC_MakeCircle(
+      siren_ary_to_pnt(p1),
+      siren_ary_to_pnt(p2),
+      siren_ary_to_pnt(p3));
+  if (gc.IsNull()) {
+    rb_raise(Qnil, "Failed to make a curve.");
+    return Qnil;
+  }
+  else {
+    TopoDS_Edge E = BRepBuilderAPI_MakeEdge(gc);
+    return siren_shape_new(E);
+  }
+}
+
+VALUE siren_topalgo_volume(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  GProp_GProps gprops;
+  BRepGProp::VolumeProperties(*shape, gprops);
+  Standard_Real vol = gprops.Mass();
+  return DBL2NUM(vol);
+}
+
+VALUE siren_topalgo_cog(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  GProp_GProps gprops;
+  BRepGProp::VolumeProperties(*shape, gprops);
+  gp_Pnt cog = gprops.CentreOfMass();
+  return siren_pnt_to_ary(cog);
+}
+
+VALUE siren_topalgo_area(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  GProp_GProps gprops;
+  BRepGProp::SurfaceProperties(*shape, gprops);
+  Standard_Real area = gprops.Mass();
+  return DBL2NUM(area);
+}

data/ext/siren2/src/trans.cpp

@@ -0,0 +1,330 @@
+#include "trans.h"
+
+VALUE sr_cTrans;
+
+gp_Trsf* siren_trans_get(VALUE obj)
+{
+  gp_Trsf* m;
+  Data_Get_Struct(obj, gp_Trsf, m);
+  return m;
+}
+
+static VALUE siren_trans_allocate(VALUE klass)
+{
+  void* p = ruby_xmalloc(sizeof(gp_Trsf));
+  new(p) gp_Trsf();
+  return Data_Wrap_Struct(klass, NULL, siren_trans_final, p);
+}
+
+VALUE siren_trans_new(const gp_Trsf& src)
+{
+  VALUE t = siren_trans_allocate(sr_cTrans);
+  gp_Trsf* pt = siren_trans_get(t);
+  *pt = src;
+  return t;
+}
+
+bool siren_trans_install()
+{
+  sr_cTrans = rb_define_class_under(sr_mSiren, "Trans", rb_cObject);
+  rb_define_alloc_func(sr_cTrans, siren_trans_allocate);
+  rb_define_method(sr_cTrans, "initialize"     , RUBY_METHOD_FUNC(siren_trans_init              ), -1);
+  rb_define_method(sr_cTrans, "to_s"           , RUBY_METHOD_FUNC(siren_trans_to_s              ), -1);
+  rb_define_method(sr_cTrans, "to_a"           , RUBY_METHOD_FUNC(siren_trans_matrix            ), -1);
+  rb_define_method(sr_cTrans, "matrix"         , RUBY_METHOD_FUNC(siren_trans_matrix            ), -1);
+  rb_define_method(sr_cTrans, "matrix="        , RUBY_METHOD_FUNC(siren_trans_set_matrix        ), -1);
+  rb_define_method(sr_cTrans, "multiply"       , RUBY_METHOD_FUNC(siren_trans_multiply          ), -1);
+  rb_define_method(sr_cTrans, "multiply!"      , RUBY_METHOD_FUNC(siren_trans_multiply_bang     ), -1);
+  rb_define_method(sr_cTrans, "power"          , RUBY_METHOD_FUNC(siren_trans_power             ), -1);
+  rb_define_method(sr_cTrans, "power!"         , RUBY_METHOD_FUNC(siren_trans_power_bang        ), -1);
+  rb_define_method(sr_cTrans, "translate!"     , RUBY_METHOD_FUNC(siren_trans_translate_bang    ), -1);
+  rb_define_method(sr_cTrans, "translatef"     , RUBY_METHOD_FUNC(siren_trans_translatef        ), -1);
+  rb_define_method(sr_cTrans, "translatef="    , RUBY_METHOD_FUNC(siren_trans_set_translatef    ), -1);
+  rb_define_method(sr_cTrans, "mirror"         , RUBY_METHOD_FUNC(siren_trans_mirror            ), -1);
+  rb_define_method(sr_cTrans, "mirror!"        , RUBY_METHOD_FUNC(siren_trans_mirror_bang       ), -1);
+  rb_define_method(sr_cTrans, "rotate!"        , RUBY_METHOD_FUNC(siren_trans_rotate_bang       ), -1);
+  rb_define_method(sr_cTrans, "scale!"         , RUBY_METHOD_FUNC(siren_trans_scale_bang        ), -1);
+  rb_define_method(sr_cTrans, "scalef"         , RUBY_METHOD_FUNC(siren_trans_scalef            ), -1);
+  rb_define_method(sr_cTrans, "scalef="        , RUBY_METHOD_FUNC(siren_trans_set_scalef        ), -1);
+  rb_define_method(sr_cTrans, "invert"         , RUBY_METHOD_FUNC(siren_trans_invert            ), -1);
+  rb_define_method(sr_cTrans, "invert!"        , RUBY_METHOD_FUNC(siren_trans_invert_bang       ), -1);
+  rb_define_method(sr_cTrans, "reverse"        , RUBY_METHOD_FUNC(siren_trans_invert            ), -1);
+  rb_define_method(sr_cTrans, "reverse!"       , RUBY_METHOD_FUNC(siren_trans_invert_bang       ), -1);
+  rb_define_method(sr_cTrans, "negative?"      , RUBY_METHOD_FUNC(siren_trans_is_negative       ), -1);
+  rb_define_method(sr_cTrans, "transform!"     , RUBY_METHOD_FUNC(siren_trans_transform_bang    ), -1);
+  rb_define_method(sr_cTrans, "move_point"     , RUBY_METHOD_FUNC(siren_trans_move_point        ), -1);
+//  rb_define_method(sr_cTrans, "rotatef"        , siren_trans_rotatef            , -1);
+//  rb_define_method(sr_cTrans, "rotatef="       , siren_trans_set_rotatef        , -1);
+  return true;
+}
+
+VALUE siren_trans_init(int argc, VALUE* argv, VALUE self)
+{
+  return self;
+}
+
+void siren_trans_final(void* p)
+{
+  gp_Trsf* t = static_cast<gp_Trsf*>(p);
+  ruby_xfree(t);
+}
+
+VALUE siren_trans_to_s(int argc, VALUE* argv, VALUE self)
+{
+  char str[256];
+  Standard_Real a11 = siren_trans_get(self)->Value(1, 1);
+  Standard_Real a12 = siren_trans_get(self)->Value(1, 2);
+  Standard_Real a13 = siren_trans_get(self)->Value(1, 3);
+  Standard_Real a14 = siren_trans_get(self)->Value(1, 4);
+  Standard_Real a21 = siren_trans_get(self)->Value(2, 1);
+  Standard_Real a22 = siren_trans_get(self)->Value(2, 2);
+  Standard_Real a23 = siren_trans_get(self)->Value(2, 3);
+  Standard_Real a24 = siren_trans_get(self)->Value(2, 4);
+  Standard_Real a31 = siren_trans_get(self)->Value(3, 1);
+  Standard_Real a32 = siren_trans_get(self)->Value(3, 2);
+  Standard_Real a33 = siren_trans_get(self)->Value(3, 3);
+  Standard_Real a34 = siren_trans_get(self)->Value(3, 4);
+  snprintf(str, sizeof(str),
+      "#<Trans:0x%x\n"
+      "    X = % 2.6f, % 2.6f, % 2.6f\n"
+      "    Y = % 2.6f, % 2.6f, % 2.6f\n"
+      "    Z = % 2.6f, % 2.6f, % 2.6f\n"
+      "    T = % 2.6f, % 2.6f, % 2.6f>",
+      -1, // (unsigned int)(uintptr_t)rb_cptr(self),
+      a11, a21, a31,
+      a12, a22, a32,
+      a13, a23, a33,
+      a14, a24, a34
+      );
+  return rb_str_new_cstr(str);
+}
+
+VALUE siren_trans_translate_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE v;
+  rb_scan_args(argc, argv, "1", &v);
+  gp_Vec vec = siren_ary_to_vec(v); 
+  gp_Trsf* trans = siren_trans_get(self);
+  trans->SetTranslation(vec);
+  return self;
+}
+
+VALUE siren_trans_rotate_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op, norm;
+  VALUE angle;
+  rb_scan_args(argc, argv, "3", &op, &norm, &angle);
+  gp_Trsf* trans = siren_trans_get(self);
+  trans->SetRotation(siren_ary_to_ax1(op, norm), angle);
+  return self;
+}
+
+/*
+VALUE siren_trans_rotatef(int argc, VALUE* argv, VALUE self)
+{
+  gp_XYZ axis;
+  Standard_Real angle;
+  if (siren_trans_get(self)->GetRotation(axis, angle) == Standard_False) {
+    return Qnil;
+  }
+  VALUE res[] = {
+    siren_pnt_new(axis.X(), axis.Y(), axis.Z()),
+    (angle)
+  };
+  return rb_ary_new_from_values(2, res);
+}
+
+VALUE siren_trans_set_rotatef(int argc, VALUE* argv, VALUE self)
+{
+  return Qnil;
+}
+*/
+
+VALUE siren_trans_scale_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op;
+  VALUE factor;
+  rb_scan_args(argc, argv, "2", &op, &factor);
+  gp_Trsf* trans  = siren_trans_get(self);
+  trans->SetScale(siren_ary_to_pnt(op), factor);
+  return self;
+}
+
+VALUE siren_trans_scalef(int argc, VALUE* argv, VALUE self)
+{
+  gp_Trsf* trans  = siren_trans_get(self);
+  Standard_Real f = trans->ScaleFactor();
+  return (f);
+}
+
+VALUE siren_trans_set_scalef(int argc, VALUE* argv, VALUE self)
+{
+  VALUE f;
+  rb_scan_args(argc, argv, "1", &f);
+  gp_Trsf* trans  = siren_trans_get(self);
+  trans->SetScaleFactor(f);
+  return (f);
+}
+
+VALUE siren_trans_mirror(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op, norm, vx;
+  rb_scan_args(argc, argv, "12", &op, &norm, &vx);
+  auto res = siren_trans_new(*siren_trans_get(self));
+  auto p = siren_trans_get(res);
+  switch (argc) {
+  case 1:
+    p->SetMirror(siren_ary_to_pnt(op));
+    break;
+  case 2:
+    p->SetMirror(siren_ary_to_ax1(op, norm));
+    break;
+  case 3:
+    p->SetMirror(siren_ary_to_ax2(op, norm, vx));
+    break;
+  }
+  return res;
+}
+
+VALUE siren_trans_mirror_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE op, norm, vx;
+  rb_scan_args(argc, argv, "12", &op, &norm, &vx);
+  switch (argc) {
+  case 1:
+    siren_trans_get(self)->SetMirror(siren_ary_to_pnt(op));
+    break;
+  case 2:
+    siren_trans_get(self)->SetMirror(siren_ary_to_ax1(op, norm));
+    break;
+  case 3:
+    siren_trans_get(self)->SetMirror(siren_ary_to_ax2(op, norm, vx));
+    break;
+  }
+  return self;
+}
+
+VALUE siren_trans_multiply(int argc, VALUE* argv, VALUE self)
+{
+  VALUE other;
+  rb_scan_args(argc, argv, "1", &other);
+  gp_Trsf* trans_me = siren_trans_get(self);
+  gp_Trsf* trans_other = siren_trans_get(other);
+  gp_Trsf t = trans_me->Multiplied(*trans_other);
+  return siren_trans_new(t);
+}
+
+VALUE siren_trans_multiply_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE other;
+  rb_scan_args(argc, argv, "1", &other);
+  gp_Trsf* trans_me = siren_trans_get(self);
+  gp_Trsf* trans_other = siren_trans_get(other);
+  trans_me->Multiply(*trans_other);
+  return self;
+}
+
+VALUE siren_trans_power(int argc, VALUE* argv, VALUE self)
+{
+  VALUE n;
+  rb_scan_args(argc, argv, "1", &n);
+  return siren_trans_new(siren_trans_get(self)->Powered(n));
+}
+
+VALUE siren_trans_power_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE n;
+  rb_scan_args(argc, argv, "1", &n);
+  siren_trans_get(self)->Power(n);
+  return self;
+}
+
+VALUE siren_trans_invert(int argc, VALUE* argv, VALUE self)
+{
+  return siren_trans_new(siren_trans_get(self)->Inverted());
+}
+
+VALUE siren_trans_invert_bang(int argc, VALUE* argv, VALUE self)
+{
+  siren_trans_get(self)->Invert();
+  return self;
+}
+
+VALUE siren_trans_is_negative(int argc, VALUE* argv, VALUE self)
+{
+  return siren_trans_get(self)->IsNegative() ? Qtrue : Qfalse;
+}
+
+VALUE siren_trans_transform_bang(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pos1, norm1, vdir1;
+  VALUE pos2, norm2, vdir2;
+  rb_scan_args(argc, argv, "33", &pos1, &norm1, &vdir1, &pos2, &norm2, &vdir2);
+  gp_Trsf* trans = siren_trans_get(self);
+  if (argc == 3) {
+    trans->SetTransformation(siren_ary_to_ax3(pos1, norm1, vdir1));
+  }
+  else if (argc == 6) {
+    trans->SetTransformation(siren_ary_to_ax3(pos1, norm1, vdir1), siren_ary_to_ax3(pos2, norm2, vdir2));
+  }
+  else {
+    rb_raise(Qnil, "Number of arguments is wrong.");
+  }
+  return self;
+}
+
+VALUE siren_trans_matrix(int argc, VALUE* argv, VALUE self)
+{
+  VALUE result[4];
+  for (int row = 1; row <= 4; row++) {
+    result[row - 1] = rb_ary_new();
+    for (int col = 1; col <= 3; col++) {
+      rb_ary_push(result[row - 1], DBL2NUM(siren_trans_get(self)->Value(col, row)));
+    }
+  }
+  return rb_ary_new_from_values(4, result);
+}
+
+VALUE siren_trans_set_matrix(int argc, VALUE* argv, VALUE self)
+{
+  VALUE ary;
+  rb_scan_args(argc, argv, "1", &ary);
+  if (RARRAY_LEN(ary) != 4) {
+    rb_raise(Qnil, "Number of items of specified array is wrong.");
+  }
+  gp_Vec x = siren_ary_to_vec(RARRAY_AREF(ary, 0));
+  gp_Vec y = siren_ary_to_vec(RARRAY_AREF(ary, 1));
+  gp_Vec z = siren_ary_to_vec(RARRAY_AREF(ary, 2));
+  gp_Vec t = siren_ary_to_vec(RARRAY_AREF(ary, 3));
+  gp_Trsf* trans = siren_trans_get(self);
+  trans->SetValues(
+      x.X(), y.X(), z.X(), t.X(), 
+      x.Y(), y.Y(), z.Y(), t.Y(), 
+      x.Z(), y.Z(), z.Z(), t.Z());
+  return self;
+}
+
+VALUE siren_trans_translatef(int argc, VALUE* argv, VALUE self)
+{
+  gp_Trsf* trans = siren_trans_get(self);
+  gp_XYZ xyz = trans->TranslationPart();
+  return siren_pnt_new(xyz.X(), xyz.Y(), xyz.Z());
+}
+
+VALUE siren_trans_set_translatef(int argc, VALUE* argv, VALUE self)
+{
+  VALUE v;
+  rb_scan_args(argc, argv, "1", &v);
+  siren_trans_get(self)->SetTranslationPart(siren_ary_to_vec(v));
+  return Qnil;
+}
+
+VALUE siren_trans_move_point(int argc, VALUE* argv, VALUE self)
+{
+  VALUE ary;
+  rb_scan_args(argc, argv, "1", &ary);
+  gp_Pnt point = siren_ary_to_pnt(ary);
+  gp_Trsf* trans = siren_trans_get(self);
+  point.Transform(*trans);
+  return siren_pnt_to_ary(point);
+}