siren2 0.1.2

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

@@ -0,0 +1,41 @@
+#include "shape/shell.h"
+
+VALUE sr_cShell;
+
+SR_SHAPE_GET(Shell, shell)
+SR_SHAPE_CHECK(Shell, shell)
+
+bool siren_shell_install()
+{
+  SR_SHAPE_INIT(Shell)
+  rb_define_method(sr_cShell, "initialize", RUBY_METHOD_FUNC(siren_shape_init),  -1);
+  rb_define_singleton_method(sr_cShell, "make", RUBY_METHOD_FUNC(siren_shell_make), -1);
+  rb_define_singleton_method(sr_cShell, "sew",  RUBY_METHOD_FUNC(siren_shell_make), -1);
+  return true;
+}
+
+VALUE siren_shell_make(int argc, VALUE* argv, VALUE self)
+{
+  VALUE ary;
+  VALUE tol;
+  rb_scan_args(argc, argv, "11", &ary, &tol);
+  BRepBuilderAPI_Sewing sewer;
+  sewer.Init();
+  if (argc == 2 && NUM2DBL(tol) >= 0.0) {
+    sewer.SetTolerance(NUM2DBL(tol));
+  }
+  int len = RARRAY_LEN(ary);
+  for (int i=0; i < len; i++) {
+    VALUE item = RARRAY_AREF(ary, i);
+    TopoDS_Shape* shape = siren_shape_get(item);
+    if (shape->IsNull()) {
+      continue;
+    }
+    TopExp_Explorer ex(*shape, TopAbs_FACE);
+    for (; ex.More(); ex.Next()) {
+      sewer.Add(ex.Current());
+    }
+  }
+  sewer.Perform();
+  return siren_shape_new(sewer.SewedShape());
+}

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

@@ -0,0 +1,256 @@
+#include "shape/solid.h"
+
+VALUE sr_cSolid;
+
+SR_SHAPE_GET(Solid, solid)
+SR_SHAPE_CHECK(Solid, solid)
+
+bool siren_solid_install()
+{
+  SR_SHAPE_INIT(Solid)
+  rb_define_method(sr_cSolid, "initialize", RUBY_METHOD_FUNC(siren_solid_init), -1);
+  rb_define_singleton_method(sr_cSolid, "box",        RUBY_METHOD_FUNC(siren_solid_box),        -1);
+  rb_define_singleton_method(sr_cSolid, "box2p",      RUBY_METHOD_FUNC(siren_solid_box2p),      -1);
+  rb_define_singleton_method(sr_cSolid, "boxax",      RUBY_METHOD_FUNC(siren_solid_boxax),      -1);
+  rb_define_singleton_method(sr_cSolid, "sphere",     RUBY_METHOD_FUNC(siren_solid_sphere),     -1);
+  rb_define_singleton_method(sr_cSolid, "cylinder",   RUBY_METHOD_FUNC(siren_solid_cylinder),   -1);
+  rb_define_singleton_method(sr_cSolid, "cone",       RUBY_METHOD_FUNC(siren_solid_cone),       -1);
+  rb_define_singleton_method(sr_cSolid, "torus",      RUBY_METHOD_FUNC(siren_solid_torus),      -1);
+  rb_define_singleton_method(sr_cSolid, "halfspace",  RUBY_METHOD_FUNC(siren_solid_halfspace),  -1);
+  rb_define_singleton_method(sr_cSolid, "prism",      RUBY_METHOD_FUNC(siren_solid_prism),      -1);
+  rb_define_singleton_method(sr_cSolid, "revol",      RUBY_METHOD_FUNC(siren_solid_revol),      -1);
+  rb_define_singleton_method(sr_cSolid, "revolution", RUBY_METHOD_FUNC(siren_solid_revolution), -1);
+  rb_define_singleton_method(sr_cSolid, "wedge",      RUBY_METHOD_FUNC(siren_solid_wedge),      -1);
+  return true;
+}
+
+VALUE siren_solid_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE* a;
+  rb_scan_args(argc, argv, "1", &a);
+  int len = RARRAY_LEN(a);
+  if (argc == 0 || len == 0) {
+    rb_raise(Qnil, "No shapes specified.");
+  }
+  BRepBuilderAPI_MakeSolid solid_maker;
+  for (int i = 0; i < len; i++) {
+    TopoDS_Shell shell = siren_shell_get(a[i]);
+    solid_maker.Add(shell);
+  }
+  if (!solid_maker.IsDone()) {
+    rb_raise(Qnil, "Failed to make a Solid.");
+  }
+  TopoDS_Shape shape = solid_maker.Shape();
+  if (shape.IsNull()) {
+    rb_raise(Qnil, "Failed to make a Solid.");
+  }
+  auto p = siren_shape_get(self);
+  *p = shape;
+  return self;
+}
+
+VALUE siren_solid_box(int argc, VALUE* argv, VALUE self)
+{
+  VALUE size, pos;
+  rb_scan_args(argc, argv, "02", &size, &pos);
+
+  Standard_Real sx, sy, sz;
+  if (argc >= 1) {
+    siren_ary_to_xyz(size, sx, sy, sz);
+  }
+  else {
+    sx = 1.0; sy = 1.0; sz = 1.0;
+  }
+
+  gp_Pnt op;
+  if (argc >= 2) {
+    Standard_Real px, py, pz;
+    siren_ary_to_xyz(pos, px, py, pz);
+    op = gp_Pnt(px, py, pz);
+  }
+  else {
+    op = gp_Pnt(0., 0., 0.);
+  }
+  if (std::fabs(sx * sy * sz) == 0.0) {
+    rb_raise(Qnil,
+      "Failed to make solid. Incorrect size specified.");
+  }
+  BRepPrimAPI_MakeBox api(op, sx, sy, sz);
+  return siren_shape_new(api.Shape());
+}
+
+VALUE siren_solid_box2p(int argc, VALUE* argv, VALUE self)
+{
+  VALUE p1, p2;
+  rb_scan_args(argc, argv, "02", &p1, &p2);
+
+  Standard_Real x1 = 0.0, y1 = 0.0, z1 = 0.0;
+  Standard_Real x2 = 1.0, y2 = 1.0, z2 = 1.0;
+
+  if (argc >= 1) {
+    siren_ary_to_xyz(p1, x1, y1, z1);
+  }
+  if (argc >= 2) {
+    siren_ary_to_xyz(p2, x2, y2, z2);
+  }
+
+  gp_Pnt point1(x1, x1, x1);
+  gp_Pnt point2(x2, x2, x2);
+
+  BRepPrimAPI_MakeBox api(point1, point2);
+  return siren_shape_new(api.Shape());
+}
+
+VALUE siren_solid_boxax(int argc, VALUE* argv, VALUE self)
+{
+  VALUE size, pos, dir;
+  rb_scan_args(argc, argv, "3", &size, &pos, &dir);
+
+  Standard_Real sx, sy, sz;
+  siren_ary_to_xyz(size, sx, sy, sz);
+
+  Standard_Real px, py, pz;
+  siren_ary_to_xyz(pos, px, py, pz);
+
+  Standard_Real dx, dy, dz;
+  siren_ary_to_xyz(dir, dx, dy, dz);
+
+  gp_Ax2 ax(gp_Pnt(px, py, pz), gp_Dir(dx, dy, dz));
+
+  BRepPrimAPI_MakeBox api(ax, sx, sy, sz);
+  return siren_shape_new(api.Shape());
+}
+
+VALUE siren_solid_sphere(int argc, VALUE* argv, VALUE self)
+{
+  VALUE r = 1.0;
+  VALUE pos;
+  rb_scan_args(argc, argv, "02", &r, &pos);
+
+  Check_Type(r, T_FLOAT);
+
+  gp_Pnt op;
+  if (argc == 2) {
+    Standard_Real px, py, pz;
+    siren_ary_to_xyz(pos, px, py, pz);
+    op = gp_Pnt(px, py, pz);
+  }
+  else {
+    op = gp_Pnt(0., 0., 0.);
+  }
+
+  if (NUM2DBL(r) < 0) {
+    rb_raise(Qnil, "Failed to make solid."
+      " Specified radius value below 0.");
+  }
+
+  BRepPrimAPI_MakeSphere api(op, NUM2DBL(r));
+  return siren_shape_new(api.Shape());
+}
+
+VALUE siren_solid_cylinder(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pos, norm;
+  VALUE r, h, a;
+  rb_scan_args(argc, argv, "5", &pos, &norm, &r, &h, &a);
+
+  Check_Type(r, T_FLOAT);
+  Check_Type(h, T_FLOAT);
+  Check_Type(a, T_FLOAT);
+
+  gp_Ax2 ax = siren_ary_to_ax2(pos, norm);
+
+  BRepPrimAPI_MakeCylinder api(ax, NUM2DBL(r), NUM2DBL(h), NUM2DBL(a));
+
+  return siren_shape_new(api.Shape());
+}
+
+VALUE siren_solid_cone(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pos, norm;
+  VALUE r1, r2, h, ang;
+  rb_scan_args(argc, argv, "6", &pos, &norm, &r1, &r2, &h, &ang);
+
+  Check_Type(r1, T_FLOAT);
+  Check_Type(r2, T_FLOAT);
+  Check_Type(h, T_FLOAT);
+  Check_Type(ang, T_FLOAT);
+
+  gp_Ax2 ax = siren_ary_to_ax2(pos, norm);
+
+  BRepPrimAPI_MakeCone api(ax, NUM2DBL(r1), NUM2DBL(r2), NUM2DBL(h), NUM2DBL(ang));
+  return siren_shape_new(api.Shape());
+}
+
+VALUE siren_solid_torus(int argc, VALUE* argv, VALUE self)
+{
+  VALUE r1, r2, ang;
+  VALUE pos, norm;
+  rb_scan_args(argc, argv, "5", &pos, &norm, &r1, &r2, &ang);
+
+  Check_Type(r1, T_FLOAT);
+  Check_Type(r2, T_FLOAT);
+  Check_Type(ang, T_FLOAT);
+
+  gp_Ax2 ax = siren_ary_to_ax2(pos, norm);
+
+  BRepPrimAPI_MakeTorus api(ax, NUM2DBL(r1), NUM2DBL(r2), NUM2DBL(ang));
+  return siren_shape_new(api.Shape());
+}
+
+VALUE siren_solid_halfspace(int argc, VALUE* argv, VALUE self)
+{
+  VALUE surf, refpnt;
+  rb_scan_args(argc, argv, "2", &surf, &refpnt);
+
+  siren_shape_check(surf);
+
+  TopoDS_Shape* shape = siren_shape_get(surf);
+  TopoDS_Solid solid;
+  gp_Pnt pnt = siren_ary_to_pnt(refpnt);
+  if (shape->ShapeType() == TopAbs_FACE) {
+    solid = BRepPrimAPI_MakeHalfSpace(TopoDS::Face(*shape), pnt);
+  }
+  else if (shape->ShapeType() == TopAbs_SHELL) {
+    solid = BRepPrimAPI_MakeHalfSpace(TopoDS::Shell(*shape), pnt);
+  }
+  else {
+    rb_raise(Qnil, "Specified shape type is not FACE or SHELL.");
+  }
+  return siren_shape_new(solid);
+}
+
+VALUE siren_solid_prism(int argc, VALUE* argv, VALUE self)
+{
+  rb_raise(Qnil, "Not implemented.");
+  return Qnil;
+}
+
+VALUE siren_solid_revol(int argc, VALUE* argv, VALUE self)
+{
+  rb_raise(Qnil, "Not implemented.");
+  return Qnil;
+}
+
+VALUE siren_solid_revolution(int argc, VALUE* argv, VALUE self)
+{
+  rb_raise(Qnil, "Not implemented.");
+  return Qnil;
+}
+
+VALUE siren_solid_wedge(int argc, VALUE* argv, VALUE self)
+{
+  VALUE dx = DBL2NUM(1.0), dy = DBL2NUM(1.0), dz = DBL2NUM(1.0),
+        x = DBL2NUM(0.5), z = DBL2NUM(0.5), X = DBL2NUM(0.5), Z = DBL2NUM(0.5);
+  rb_scan_args(argc, argv, "07", &dx, &dy, &dz, &x, &z, &X, &Z);
+  try {
+    BRepPrimAPI_MakeWedge api(NUM2DBL(dx), NUM2DBL(dy), NUM2DBL(dz),
+        NUM2DBL(x), NUM2DBL(z), NUM2DBL(X), NUM2DBL(Z));
+    TopoDS_Shape s = api.Shape();
+    return siren_shape_new(s);
+  }
+  catch (...) {
+    rb_raise(Qnil, "Failed to make a wedge.");
+  }
+  return Qnil;
+}

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

@@ -0,0 +1,68 @@
+#include "shape/vertex.h"
+
+#define rb_array_p(x) RB_TYPE_P(x, T_ARRAY)
+
+VALUE sr_cVertex;
+
+SR_SHAPE_GET(Vertex, vertex)
+SR_SHAPE_CHECK(Vertex, vertex)
+
+bool siren_vertex_install()
+{
+  SR_SHAPE_INIT(Vertex)
+  rb_define_method(sr_cVertex, "initialize", RUBY_METHOD_FUNC(siren_vertex_init), -1);
+  rb_define_method(sr_cVertex, "xyz",        RUBY_METHOD_FUNC(siren_vertex_xyz),  -1);
+  rb_define_method(sr_cVertex, "to_a",       RUBY_METHOD_FUNC(siren_vertex_xyz),  -1);
+  rb_define_method(sr_cVertex, "to_v",       RUBY_METHOD_FUNC(siren_vertex_to_v), -1);
+  return true;
+}
+
+VALUE siren_vertex_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE* a;
+  VALUE len;
+  rb_scan_args(argc, argv, "*", &a, &len);
+
+  Standard_Real x = 0.0, y = 0.0, z = 0.0;
+  if (len > 0 && rb_array_p(a[0])) {
+    gp_Pnt p = siren_ary_to_pnt(a[0]);
+    x = p.X(); y = p.Y(); z = p.Z();
+  }
+  else {
+    if (len >= 1) {
+      if (FIXNUM_P(a[0]))
+        x = DBL2NUM(a[0]);
+      else if (RB_FLOAT_TYPE_P(a[0]))
+        x = VALUE(a[0]);
+    }
+    if (len >= 2) {
+      if (FIXNUM_P(a[1]))
+        y = DBL2NUM(a[1]);
+      else if (RB_FLOAT_TYPE_P(a[1]))
+        y = VALUE(a[1]);
+    }
+    if (len >= 3) {
+      if (FIXNUM_P(a[2]))
+        z = DBL2NUM(a[2]);
+      else if (RB_FLOAT_TYPE_P(a[2]))
+        z = VALUE(a[2]);
+    }
+  }
+  TopoDS_Vertex v = BRepBuilderAPI_MakeVertex(gp_Pnt(x, y, z));
+  auto p = siren_shape_get(self);
+  *p = v;
+  return self;
+}
+
+VALUE siren_vertex_xyz(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Vertex vertex = siren_vertex_get(self);
+  return siren_pnt_to_ary(BRep_Tool::Pnt(vertex));
+}
+
+VALUE siren_vertex_to_v(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Vertex vertex = siren_vertex_get(self);
+  gp_Pnt p = BRep_Tool::Pnt(vertex);
+  return siren_vec_new(p.X(), p.Y(), p.Z());
+}

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

@@ -0,0 +1,100 @@
+#include "shape/wire.h"
+#include "shape.h"
+
+VALUE sr_cWire;
+
+SR_SHAPE_GET(Wire, wire)
+SR_SHAPE_CHECK(Wire, wire)
+
+bool siren_wire_install()
+{
+  SR_SHAPE_INIT(Wire)
+  rb_define_method(sr_cWire, "initialize",    RUBY_METHOD_FUNC(siren_shape_init),         -1);
+  rb_define_method(sr_cWire, "ordered_edges", RUBY_METHOD_FUNC(siren_wire_ordered_edges), -1);
+  rb_define_singleton_method(sr_cWire, "make", RUBY_METHOD_FUNC(siren_wire_make), -1);
+  rb_define_singleton_method(sr_cWire, "join", RUBY_METHOD_FUNC(siren_wire_make), -1);
+  return true;
+}
+
+VALUE siren_wire_ordered_edges(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Wire wire = siren_wire_get(self);
+  VALUE res = rb_ary_new();
+  for (BRepTools_WireExplorer exp(wire); exp.More(); exp.Next()) {
+    TopoDS_Edge e = exp.Current();
+    rb_ary_push(res, siren_shape_new(e));
+  }
+  return res;
+}
+
+VALUE siren_wire_make(int argc, VALUE* argv, VALUE self)
+{
+  VALUE objs;
+  VALUE tol;
+  rb_scan_args(argc, argv, "11", &objs, &tol);
+  BRepBuilderAPI_MakeWire api;
+#ifdef USE_WIRE_FIX
+  ShapeFix_Wire sfw;
+  handle<ShapeExtend_WireData> wd = new ShapeExtend_WireData();
+  ShapeFix_ShapeTolerance FTol;
+  int osize = RARRAY_LEN(objs);
+  for (int i = 0; i < osize ; i++) {
+    VALUE obj = RARRAY_AREF(objs, i);
+    TopoDS_Shape* s = siren_shape_get(obj);
+    if (s->IsNull()) {
+      continue;
+    }
+    TopExp_Explorer exp(*s, TopAbs_EDGE);
+    for (; exp.More(); exp.Next()) {
+      wd->Add(TopoDS::Edge(exp.Current()));
+    }
+  }
+  if (wd->NbEdges() == 0) {
+    return Qnil;
+  }
+  sfw.Load(wd);
+  sfw.Perform();
+  for (int i = 1; i <= sfw.NbEdges(); i ++) {
+    TopoDS_Edge e = sfw.WireData()->Edge(i);
+    FTol.SetTolerance(e, argc == 1 ? 0.01 : NUM2DBL(tol), TopAbs_VERTEX);
+    api.Add(e);
+  }
+  return siren_shape_new(api.Shape());
+#else
+  ShapeFix_ShapeTolerance fixtol;
+  bool has_tol = argc == 2;
+  for (int i = 0; i < RARRAY_LEN(objs); i++) {
+    TopoDS_Shape* shape = siren_shape_get(RARRAY_AREF(objs, i));
+    if (shape->ShapeType() == TopAbs_EDGE) {
+      if (has_tol) {
+        fixtol.SetTolerance(*shape, NUM2DBL(tol), TopAbs_VERTEX);
+      }
+      api.Add(TopoDS::Edge(*shape));
+    }
+    else if (shape->ShapeType() == TopAbs_WIRE) {
+      if (has_tol) {
+        fixtol.SetTolerance(*shape, NUM2DBL(tol), TopAbs_VERTEX);
+        fixtol.SetTolerance(*shape, NUM2DBL(tol), TopAbs_EDGE);
+      }
+      api.Add(TopoDS::Wire(*shape));
+    }
+  }
+  api.Build();
+  if (!api.IsDone()) {
+    switch (api.Error()) {
+      case BRepBuilderAPI_EmptyWire:
+        rb_raise(Qnil, "Failed to make a wire. (Empty wire)");
+        break;
+      case BRepBuilderAPI_DisconnectedWire:
+        rb_raise(Qnil, "Failed to make a wire. (Disconnected wire)");
+        break;
+      case BRepBuilderAPI_NonManifoldWire:
+        rb_raise(Qnil, "Failed to make a wire. (Non manifold wire)");
+        break;
+      default: break;
+    }
+  }
+#endif
+  return siren_shape_new(api.Wire());
+}
+