siren2 0.1.2

data/ext/siren2/src/curve/line.cpp

@@ -0,0 +1,24 @@
+/**
+ * line.cpp
+ * Implementation of singleton methods for LINE
+ */
+
+#include "curve.h"
+
+VALUE sr_cLine;
+
+SR_CURVE_GET(Line, line)
+
+bool siren_line_install()
+{
+  SR_CURVE_INIT(Line)
+  rb_define_method(sr_cLine, "initialize", RUBY_METHOD_FUNC(siren_curve_init), -1);
+  rb_define_method(sr_cLine, "dir",        RUBY_METHOD_FUNC(siren_line_dir),   -1);
+  return true;
+}
+
+VALUE siren_line_dir(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_Line> line = siren_line_get(self);
+  return siren_dir_to_ary(line->Lin().Direction());
+}

data/ext/siren2/src/curve/offsetcurve.cpp

@@ -0,0 +1,17 @@
+/**
+ * offsetcurve.cpp
+ * Implementation of singleton methods for OFFSETCURVE
+ */
+
+#include "curve.h"
+
+VALUE sr_cOffsetCurve;
+
+SR_CURVE_GET(OffsetCurve, offsetcurve)
+
+bool siren_offsetcurve_install()
+{
+  SR_CURVE_INIT(OffsetCurve)
+  rb_define_method(sr_cOffsetCurve, "initialize", RUBY_METHOD_FUNC(siren_curve_init), -1);
+  return true;
+}

data/ext/siren2/src/curve/parabola.cpp

@@ -0,0 +1,17 @@
+/**
+ * parabola.cpp
+ * Implementation of singleton methods for PARABOLA
+ */
+
+#include "curve.h"
+
+VALUE sr_cParabola;
+
+SR_CURVE_GET(Parabola, parabola)
+
+bool siren_parabola_install()
+{
+  SR_CURVE_INIT(Parabola)
+  rb_define_method(sr_cParabola, "initialize", RUBY_METHOD_FUNC(siren_curve_init), -1);
+  return true;
+}

data/ext/siren2/src/filler.cpp

@@ -0,0 +1,191 @@
+#include "filler.h"
+
+VALUE sr_cFiller;
+
+VALUE siren_filler_allocate(VALUE klass)
+{
+  void* p = ruby_xmalloc(sizeof(BRepFill_Filling));
+  new(p) BRepFill_Filling();
+  return Data_Wrap_Struct(klass, NULL, siren_filler_final, p);
+}
+
+BRepFill_Filling* siren_filler_get(VALUE obj)
+{
+  BRepFill_Filling* m;
+  Data_Get_Struct(obj, BRepFill_Filling, m);
+  return m;
+}
+
+bool siren_filler_install()
+{
+  sr_cFiller = rb_define_class_under(sr_mSiren, "Filler", rb_cObject);
+  rb_define_alloc_func(sr_cFiller, siren_filler_allocate);
+
+  rb_define_method(sr_cFiller, "initialize", RUBY_METHOD_FUNC(siren_filler_init),      -1);
+  rb_define_method(sr_cFiller, "add_bound",  RUBY_METHOD_FUNC(siren_filler_add_bound), 2);
+  rb_define_method(sr_cFiller, "add",        RUBY_METHOD_FUNC(siren_filler_add),       2);
+  rb_define_method(sr_cFiller, "build",      RUBY_METHOD_FUNC(siren_filler_build),     0);
+  rb_define_method(sr_cFiller, "done?",      RUBY_METHOD_FUNC(siren_filler_is_done),   0);
+  rb_define_method(sr_cFiller, "face",       RUBY_METHOD_FUNC(siren_filler_face),      0);
+  rb_define_method(sr_cFiller, "g0error",    RUBY_METHOD_FUNC(siren_filler_g0error),   1);
+  rb_define_method(sr_cFiller, "g1error",    RUBY_METHOD_FUNC(siren_filler_g1error),   1);
+  rb_define_method(sr_cFiller, "g2error",    RUBY_METHOD_FUNC(siren_filler_g2error),   1);
+  return true;
+}
+
+VALUE
+siren_filler_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE degree, nbptsoncur, nbiter;
+  VALUE anisotropie;
+  VALUE tol2d, tol3d, tolang, tolcurv;
+  VALUE maxdeg, maxsegs;
+  // rb_scan_args(argc, argv, "|iiibffffii",
+  //     &degree, &nbptsoncur, &nbiter, &anisotropie,
+  //     &tol2d, &tol3d, &tolang, &tolcurv, &maxdeg, &maxsegs);
+  // issue: unsupports over 10 args?
+  rb_scan_args(argc, argv, "19",
+      &degree, &nbptsoncur, &nbiter, &anisotropie,
+      &tol2d, &tol3d, &tolang, &tolcurv, &maxdeg, &maxsegs);
+
+  auto p = siren_filler_get(self);
+
+  switch (argc) {
+    case 1:
+      p->SetResolParam(NUM2INT(degree));
+      break;
+    case 2:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur));
+      break;
+    case 3:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur), NUM2INT(nbiter));
+      break;
+    case 4:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur), NUM2INT(nbiter), anisotropie == Qtrue);
+      break;
+/*
+    case 5:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur), NUM2INT(nbiter), anisotropie == Qtrue);
+      p->SetConstrParam(NUM2DBL(tol2d));
+      break;
+    case 6:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur), NUM2INT(nbiter), anisotropie == Qtrue);
+      p->SetConstrParam(NUM2DBL(tol2d), NUM2DBL(tol3d));
+      break;
+    case 7:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur), NUM2INT(nbiter), anisotropie == Qtrue);
+      p->SetConstrParam(NUM2DBL(tol2d), NUM2DBL(tol3d), NUM2DBL(tolang));
+      break;
+    case 8:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur), NUM2INT(nbiter), anisotropie == Qtrue);
+      p->SetConstrParam(NUM2DBL(tol2d), NUM2DBL(tol3d), NUM2DBL(tolang), NUM2DBL(tolcurv));
+      break;
+    case 9:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur), NUM2INT(nbiter), anisotropie == Qtrue);
+      p->SetConstrParam(NUM2DBL(tol2d), NUM2DBL(tol3d), NUM2DBL(tolang), NUM2DBL(tolcurv), NUM2INT(maxdeg));
+      break;
+    case 10:
+      p->SetResolParam(NUM2INT(degree), NUM2INT(nbptsoncur), NUM2INT(nbiter), anisotropie == Qtrue);
+      p->SetConstrParam(NUM2DBL(tol2d), NUM2DBL(tol3d), NUM2DBL(tolang), NUM2DBL(tolcurv), NUM2INT(maxdeg), NUM2INT(maxsegs));
+      break;
+*/
+    default:
+      break;
+  }
+  return self;
+}
+
+void siren_filler_final( void* p)
+{
+  BRepFill_Filling* pp = static_cast<BRepFill_Filling*>(p);
+  ruby_xfree(pp);
+}
+
+VALUE siren_filler_add_bound(int argc, VALUE* argv, VALUE self)
+{
+  VALUE edge;
+  VALUE order;
+  rb_scan_args(argc, argv, "2", &edge, &order);
+
+  auto e = siren_edge_get(edge);
+  siren_filler_get(self)->Add(e, (GeomAbs_Shape)NUM2INT(order),
+      /* IsBound= */ Standard_True);
+  return Qnil;
+}
+
+VALUE siren_filler_add(int argc, VALUE* argv, VALUE self)
+{
+  VALUE obj;
+  VALUE order;
+  rb_scan_args(argc, argv, "11", &obj, &order);
+  if (order != Qnil) {
+    TopoDS_Edge e = siren_edge_get(obj);
+    siren_filler_get(self)->Add(e, (GeomAbs_Shape)NUM2INT(order),
+        /* IsBound= */ Standard_False);
+  }
+  else {
+    gp_Pnt pnt = siren_ary_to_pnt(obj);
+    siren_filler_get(self)->Add(pnt);
+  }
+  return Qnil;
+}
+
+VALUE siren_filler_build(int argc, VALUE* argv, VALUE self)
+{
+  siren_filler_get(self)->Build();
+  return Qnil;
+}
+
+VALUE siren_filler_is_done(int argc, VALUE* argv, VALUE self)
+{
+  return siren_filler_get(self)->IsDone() == Standard_True ?
+    Qtrue : Qfalse;
+}
+
+VALUE siren_filler_face(int argc, VALUE* argv, VALUE self)
+{
+  TopoDS_Face f = siren_filler_get(self)->Face();
+  return siren_shape_new(f);
+}
+
+VALUE siren_filler_g0error(int argc, VALUE* argv, VALUE self)
+{
+  VALUE index;
+  rb_scan_args(argc, argv, "01", &index);
+  Standard_Real value;
+  if (index != Qnil) {
+    value = siren_filler_get(self)->G0Error(NUM2INT(index));
+  }
+  else {
+    value = siren_filler_get(self)->G0Error();
+  }
+  return (value);
+}
+
+VALUE siren_filler_g1error(int argc, VALUE* argv, VALUE self)
+{
+  VALUE index;
+  rb_scan_args(argc, argv, "01", &index);
+  Standard_Real value;
+  if (index != Qnil) {
+    value = siren_filler_get(self)->G1Error(NUM2INT(index));
+  }
+  else {
+    value = siren_filler_get(self)->G1Error();
+  }
+  return (value);
+}
+
+VALUE siren_filler_g2error(int argc, VALUE* argv, VALUE self)
+{
+  VALUE index;
+  rb_scan_args(argc, argv, "01", &index);
+  Standard_Real value;
+  if (index != Qnil) {
+    value = siren_filler_get(self)->G2Error(NUM2INT(index));
+  }
+  else {
+    value = siren_filler_get(self)->G2Error();
+  }
+  return (value);
+}

data/ext/siren2/src/heal.cpp

@@ -0,0 +1,92 @@
+#include "heal.h"
+
+#ifdef SR_ENABLE_HEALING
+
+VALUE siren_heal_outerwire(int argc, VALUE* argv, VALUE self)
+{
+  VALUE tol = DBL2NUM(1.0e-1);
+  rb_scan_args(argc, argv, "01", &tol);
+
+  TopoDS_Shape* shape = siren_shape_get(self);
+
+  VALUE res = Qnil;
+
+  if (shape->ShapeType() == TopAbs_FACE) {
+    TopoDS_Face face = TopoDS::Face(*shape);
+    TopoDS_Wire wire = ShapeAnalysis::OuterWire(face);
+    // ShapeAnalysis_FreeBounds
+    // ::ConnectWiresToWires
+    res = siren_shape_new(wire);
+  }
+  else {
+    ShapeAnalysis_FreeBounds safb(*shape, NUM2DBL(tol));
+    TopoDS_Compound comp = safb.GetClosedWires();
+    res = siren_shape_new(comp);
+  }
+  return res;
+}
+
+VALUE siren_heal_fix( VALUE self)
+{
+  TopoDS_Shape* shape = siren_shape_get(self);
+  VALUE res = Qnil;
+
+  opencascade::handle<ShapeFix_Shape> sfs = new ShapeFix_Shape();
+  sfs->Init(*shape);
+  sfs->SetPrecision(1.0);
+  sfs->SetMinTolerance(1.0e-6);
+  sfs->SetMaxTolerance(1.0e-1);
+
+  switch (shape->ShapeType()) {
+    case TopAbs_SOLID:
+      sfs->FixSolidTool()->FixShellMode() = 1;
+    case TopAbs_SHELL:
+      sfs->FixShellTool()->FixFaceMode() = 1;
+      sfs->FixShellTool()->FixOrientationMode() = 1;
+    case TopAbs_FACE:
+      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;
+    case TopAbs_WIRE:
+      //sfs->FixWireTool()->FixAddCurve3dMode() = 1;
+      //sfs->FixWireTool()->FixAddPCurveMode() = 1;
+      sfs->FixWireTool()->FixConnectedMode() = 1;
+      sfs->FixWireTool()->FixDegeneratedMode() = 1;
+      sfs->FixWireTool()->FixEdgeCurvesMode() = 1;
+      //sfs->FixWireTool()->FixGaps2dMode() = 1;
+      sfs->FixWireTool()->FixGaps3dMode() = 1;
+      sfs->FixWireTool()->FixGapsByRangesMode() = 1;
+      sfs->FixWireTool()->FixIntersectingEdgesMode() = 1;
+      sfs->FixWireTool()->FixLackingMode() = 1;
+      sfs->FixWireTool()->FixNonAdjacentIntersectingEdgesMode() = 1;
+      sfs->FixWireTool()->FixNotchedEdgesMode() = 1;
+      //sfs->FixWireTool()->FixRemoveCurve3dMode() = 1;
+      //sfs->FixWireTool()->FixRemovePCurveMode() = 1;
+      sfs->FixWireTool()->FixReorderMode() = 1;
+      //sfs->FixWireTool()->FixReversed2dMode() = 1;
+      sfs->FixWireTool()->FixSameParameterMode() = 1;
+      sfs->FixWireTool()->FixSeamMode() = 1;
+      sfs->FixWireTool()->FixSelfIntersectingEdgeMode() = 1;
+      sfs->FixWireTool()->FixSelfIntersectionMode() = 1;
+      sfs->FixWireTool()->FixShiftedMode() = 1;
+      sfs->FixWireTool()->FixSmallMode() = 1;
+      sfs->FixWireTool()->FixVertexToleranceMode() = 1;
+    default:
+      sfs->FixVertexPositionMode() = 1;
+  }
+
+  sfs->Perform();
+
+  TopoDS_Shape fixedshape = sfs->Shape();
+  if (!fixedshape.IsNull()) {
+    res = siren_shape_new(fixedshape);
+  }
+
+  return res;
+}
+#endif

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

@@ -0,0 +1,85 @@
+#include "io/iges.h"
+
+#ifdef SR_ENABLE_IGES
+
+bool siren_iges_install()
+{
+#if 0
+  rb_define_class_method(sr_mSiren, "save_iges", RUBY_METHOD_FUNC(siren_iges_save), -1);
+  rb_define_class_method(sr_mSiren, "load_iges", RUBY_METHOD_FUNC(siren_iges_load), -1);
+#else
+  rb_define_method      (sr_mSiren, "save_iges", RUBY_METHOD_FUNC(siren_iges_save), -1);
+  rb_define_method      (sr_mSiren, "load_iges", RUBY_METHOD_FUNC(siren_iges_load), -1);
+#endif
+  return true;
+}
+
+VALUE siren_iges_save(int argc, VALUE* argv, VALUE self)
+{
+  VALUE target;
+  VALUE path;
+  rb_scan_args(argc, argv, "2", &target, &path);
+
+  IGESControl_Controller::Init();
+//  IGESControl_Writer writer(Interface_Static::CVal("XSTEP.iges.unit"),
+//    Interface_Static::IVal("XSTEP.iges.writebrep.mode"));
+  IGESControl_Writer writer(Interface_Static::CVal("XSTEP.iges.unit"), 1);  // the second argument "1" sets the OCCT => IGES conversion method to "BRep"  
+
+  writer.AddShape(*siren_shape_get(target));
+  writer.ComputeModel();
+
+  std::ofstream fst(RSTRING_PTR(path), std::ios_base::out);
+  if (writer.Write(fst) == Standard_False) {
+    rb_raise(Qnil, "Failed to save IGES to %S.", (wchar_t*)RSTRING_PTR(path));
+  }
+
+  return Qnil;
+}
+
+VALUE siren_iges_load(int argc, VALUE* argv, VALUE self)
+{
+  VALUE path;
+  VALUE as_ary = Qfalse;
+  rb_scan_args(argc, argv, "11", &path, &as_ary);
+
+  IGESControl_Reader iges_reader;
+  int stat = iges_reader.ReadFile((Standard_CString)RSTRING_PTR(path));
+  VALUE result;
+
+  if (stat == IFSelect_RetDone) {
+    try {
+      iges_reader.TransferRoots();
+    }
+    catch (...) {
+      rb_raise(Qnil, "Failed to TransferRoots() with an IGES.");
+    }
+
+    if (as_ary == Qtrue) {
+      // Return array
+      result = rb_ary_new();
+      for (int i=1; i <= iges_reader.NbShapes(); i++) {
+        try {
+          TopoDS_Shape shape = iges_reader.Shape(i);
+          VALUE mrshape = siren_shape_new(shape);
+          rb_ary_push(result, mrshape);
+        }
+        catch(...) {
+          rb_warn("Failed to get entitiy at %d.", i);
+        }
+      }
+      if (RARRAY_LEN(result) < 1) {
+        result = Qnil;
+      }
+    }
+    else {
+      // As one shape
+      result = siren_shape_new(iges_reader.OneShape());
+    }
+  }
+  else {
+    rb_raise(Qnil, "Failed to load IGES from %S.", (wchar_t*)RSTRING_PTR(path));
+  }
+  return result;
+}
+
+#endif

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

@@ -0,0 +1,47 @@
+#include "io/step.h"
+
+#ifdef SR_ENABLE_STEP
+
+bool siren_step_install()
+{
+#if 0
+  // Class method
+  rb_define_class_method(sr_mSiren, "save_step",  RUBY_METHOD_FUNC(siren_step_save), -1);
+  rb_define_class_method(sr_mSiren, "load_step",  RUBY_METHOD_FUNC(siren_step_load), -1);
+#endif
+  // For mix-in
+  rb_define_method      (sr_mSiren, "save_step",  RUBY_METHOD_FUNC(siren_step_save), -1);
+  rb_define_method      (sr_mSiren, "load_step",  RUBY_METHOD_FUNC(siren_step_load), -1);
+  return true;
+}
+
+VALUE siren_step_save(int argc, VALUE* argv, VALUE self)
+{
+  VALUE s;
+  VALUE path;
+  rb_scan_args(argc, argv, "2", &s, &path);
+  TopoDS_Shape* shape = siren_shape_get(s);
+  STEPControl_Writer writer;
+  if (writer.Transfer(*shape, STEPControl_AsIs, Standard_True) != IFSelect_RetDone) {
+    rb_raise(Qnil, "Failed to transfer Shape to STEP entity.");
+  }
+  if (writer.Write(RSTRING_PTR(path)) != IFSelect_RetDone) {
+    rb_raise(Qnil, "Failed to write STEP to %S.", (wchar_t*)RSTRING_PTR(path));
+  }
+  return Qnil;
+}
+
+VALUE siren_step_load(int argc, VALUE* argv, VALUE self)
+{
+  VALUE path;
+  rb_scan_args(argc, argv, "1", &path);
+  STEPControl_Reader reader;
+  if (!reader.ReadFile((Standard_CString)RSTRING_PTR(path))) {
+     rb_raise(Qnil, "Failed to load STEP from %S.", (wchar_t*)RSTRING_PTR(path));
+  }
+  reader.NbRootsForTransfer();
+  reader.TransferRoots();
+  return siren_shape_new(reader.OneShape());
+}
+
+#endif