siren2 0.1.2

data/ext/siren2/src/common.cpp

@@ -0,0 +1,18 @@
+#include "common.h"
+
+void siren_ary_to_xyz(VALUE ary, Standard_Real& x, Standard_Real& y, Standard_Real& z)
+{
+  x = 0.0; y = 0.0; z = 0.0;
+
+  int len = RARRAY_LEN(ary);
+  if (len > 0) {
+    x = NUM2DBL(RARRAY_AREF(ary, 0));
+  }
+  if (len > 1) {
+    y = NUM2DBL(RARRAY_AREF(ary, 1));
+  }
+  if (len > 2) {
+    z = NUM2DBL(RARRAY_AREF(ary, 2));
+  }
+  return;
+}

data/ext/siren2/src/curve.cpp

@@ -0,0 +1,75 @@
+/*
+ * Document-class: Curve
+ *
+ */
+
+#include "curve.h"
+
+VALUE sr_cCurve;
+
+VALUE siren_curve_allocate(VALUE klass)
+{
+  void* p = ruby_xmalloc(sizeof(handle<Geom_Curve>));
+  new(p) handle<Geom_Curve>();
+  return Data_Wrap_Struct(klass, NULL, siren_curve_final, p);
+}
+
+handle<Geom_Curve>* siren_curve_get(VALUE obj)
+{
+  handle<Geom_Curve>* m;
+  Data_Get_Struct(obj, handle<Geom_Curve>, m);
+  return m;
+}
+
+VALUE siren_curve_new(handle<Geom_Curve> curve)
+{
+  VALUE klass;
+  GeomAbs_CurveType type = siren_curve_geomtype_native(curve);
+  switch (type) {
+    case GeomAbs_Line:         klass = sr_cLine; break;
+    case GeomAbs_Circle:       klass = sr_cCircle; break;
+    case GeomAbs_Ellipse:      klass = sr_cEllipse; break;
+    case GeomAbs_Hyperbola:    klass = sr_cHyperbola; break;
+    case GeomAbs_Parabola:     klass = sr_cParabola; break;
+    case GeomAbs_BezierCurve:  klass = sr_cBzCurve; break;
+    case GeomAbs_BSplineCurve: klass = sr_cBSCurve; break;
+    case GeomAbs_OffsetCurve:  klass = sr_cOffsetCurve; break;
+    default: rb_raise(Qnil, "Failed to make Curve object."); break;
+  }
+  auto val = siren_curve_allocate(klass);
+  auto pc = siren_curve_get(val);
+  *pc = curve;
+  return val;
+}
+
+bool siren_curve_install()
+{
+  sr_cCurve = rb_define_class_under(sr_mSiren, "Curve", rb_cObject);
+  rb_define_alloc_func(sr_cCurve, siren_curve_allocate);
+  rb_define_method(sr_cCurve, "initialize", RUBY_METHOD_FUNC(siren_curve_init), -1);
+  siren_line_install();
+  siren_circle_install();
+  siren_ellipse_install();
+  siren_hyperbola_install();
+  siren_parabola_install();
+  siren_bzcurve_install();
+  siren_bscurve_install();
+  siren_offsetcurve_install();
+  return true;
+}
+
+VALUE siren_curve_init(int argc, VALUE* argv, VALUE self)
+{
+  rb_raise(Qnil, "private method `new' called for Curve:Class");
+  return Qnil;
+}
+
+void siren_curve_final(void* p)
+{
+  handle<Geom_Curve>* hgcurve = static_cast<handle<Geom_Curve>*>(p);
+  if (!(*hgcurve).IsNull()) {
+    (*hgcurve).Nullify();
+  }
+  ruby_xfree(p);
+}
+

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

@@ -0,0 +1,118 @@
+/**
+ * bscurve.cpp
+ */
+
+#include "curve.h"
+
+VALUE sr_cBSCurve;
+
+SR_CURVE_GET(BSplineCurve, bscurve)
+
+bool siren_bscurve_install()
+{
+  SR_CURVE_INIT(BSCurve)
+  rb_define_method(sr_cBSCurve, "initialize", RUBY_METHOD_FUNC(siren_bscurve_init),    -1);
+  rb_define_method(sr_cBSCurve, "degree",     RUBY_METHOD_FUNC(siren_bscurve_degree),  -1);
+  rb_define_method(sr_cBSCurve, "knots",      RUBY_METHOD_FUNC(siren_bscurve_knots),   -1);
+  rb_define_method(sr_cBSCurve, "mults",      RUBY_METHOD_FUNC(siren_bscurve_mults),   -1);
+  rb_define_method(sr_cBSCurve, "poles",      RUBY_METHOD_FUNC(siren_bscurve_poles),   -1);
+  rb_define_method(sr_cBSCurve, "weights",    RUBY_METHOD_FUNC(siren_bscurve_weights), -1);
+  return true;
+}
+
+VALUE siren_bscurve_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE d;
+  VALUE ks, ms, ps, ws;
+  rb_scan_args(argc, argv, "41", &d, &ks, &ms, &ps, &ws);
+
+  int plen = RARRAY_LEN(ps);
+
+  TColgp_Array1OfPnt poles(0, plen - 1);
+  TColStd_Array1OfReal weights(0, plen - 1);
+  for (int i=0; i < plen; i++) {
+    poles.SetValue(i, siren_ary_to_pnt(RARRAY_AREF(ps, i)));
+    if (argc >= 5) {
+      VALUE w = RARRAY_AREF(ws, i);
+      weights.SetValue(i, VALUE(w));
+    }
+    else {
+      weights.SetValue(i, 1.0);
+    }
+  }
+
+  int klen = RARRAY_LEN(ks);
+  TColStd_Array1OfReal knots(0, klen - 1);
+  TColStd_Array1OfInteger mults(0, klen - 1);
+
+  for (int i=0; i < klen; i++) {
+    VALUE knot = RARRAY_AREF(ks, i);
+    knots.SetValue(i, VALUE(knot));
+    VALUE mult = RARRAY_AREF(ms, i);
+    mults.SetValue(i, (Standard_Integer)DBL2NUM(mult));
+  }
+
+  handle<Geom_Curve> curve
+    = new Geom_BSplineCurve(poles, weights, knots, mults, d, Standard_False);
+
+  // initialize において self は既に rb_instance_alloc されているので、
+  // DATA_PTR と DATA_TYPE のみを設定する
+  void* p = ruby_xmalloc(sizeof(handle<Geom_Curve>));
+  handle<Geom_Curve>* hgcurve = new(p) handle<Geom_Curve>();
+  *hgcurve = curve;
+  DATA_PTR(self) = hgcurve;
+#if 0
+  DATA_TYPE(self) = &siren_bscurve_type;
+#endif
+  return self;
+}
+
+VALUE siren_bscurve_degree(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_BSplineCurve> curve = siren_bscurve_get(self);
+  return INT2FIX((int)curve->Degree());
+}
+
+VALUE siren_bscurve_knots(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_BSplineCurve> curve = siren_bscurve_get(self);
+  VALUE knots = rb_ary_new();
+  for (int i = 1; i <= curve->NbKnots(); i++) {
+    rb_ary_push(knots, (curve->Knot(i)));
+  }
+  return knots;
+}
+
+VALUE siren_bscurve_mults(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_BSplineCurve> curve = siren_bscurve_get(self);
+  VALUE mults = rb_ary_new();
+  for (int i = 1; i <= curve->NbKnots(); i++) {
+    rb_ary_push(mults, INT2FIX(curve->Multiplicity(i)));
+  }
+  return mults;
+}
+
+VALUE siren_bscurve_poles(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_BSplineCurve> curve = siren_bscurve_get(self);
+  VALUE poles = rb_ary_new();
+  for (int i = 1; i <= curve->NbPoles(); i++) {
+    VALUE item = rb_ary_new();
+    rb_ary_push(item, (curve->Pole(i).X()));
+    rb_ary_push(item, (curve->Pole(i).Y()));
+    rb_ary_push(item, (curve->Pole(i).Z()));
+    rb_ary_push(poles, item);
+  }
+  return poles;
+}
+
+VALUE siren_bscurve_weights(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_BSplineCurve> curve = siren_bscurve_get(self);
+  VALUE weights = rb_ary_new();
+  for (int i = 1; i <= curve->NbPoles(); i++) {
+    rb_ary_push(weights, (curve->Weight(i)));
+  }
+  return weights;
+}

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

@@ -0,0 +1,55 @@
+/**
+ * bzcurve.cpp
+ */
+
+#include "curve.h"
+
+VALUE sr_cBzCurve;
+
+SR_CURVE_GET(BezierCurve, bzcurve)
+
+bool siren_bzcurve_install()
+{
+  SR_CURVE_INIT(BzCurve)
+  rb_define_method(sr_cBzCurve, "initialize", RUBY_METHOD_FUNC(siren_bzcurve_init), -1);
+  return true;
+}
+
+VALUE siren_bzcurve_init(int argc, VALUE* argv, VALUE self)
+{
+  VALUE ps, ws;
+  rb_scan_args(argc, argv, "11", &ps, &ws);
+  bool has_weight = argc == 2;
+  int plen = RARRAY_LEN(ps);
+  TColgp_Array1OfPnt poles(1, plen);
+  TColStd_Array1OfReal weights(1, plen);
+  // Start index of weights must be 1. Crash construction of Geom_BezierCurve
+  // if another index specified.
+  for (int i = 0; i < plen; i++) {
+    poles.SetValue(i + 1, siren_ary_to_pnt(RARRAY_AREF(ps, i)));
+    if (has_weight) {
+      VALUE w = RARRAY_AREF(ws, i);
+      weights.SetValue(i + 1, VALUE(w));
+    }
+  }
+  handle<Geom_Curve> curve = nullptr;
+  try {
+    if (has_weight) {
+      curve = new Geom_BezierCurve(poles, weights);
+    }
+    else {
+      curve = new Geom_BezierCurve(poles);
+    }
+  }
+  catch (...) {
+    rb_raise(Qnil, "Failed to make a BzCurve.");
+  }
+  void* p = ruby_xmalloc(sizeof(handle<Geom_Curve>));
+  handle<Geom_Curve>* hgcurve = new(p) handle<Geom_Curve>();
+  *hgcurve = curve;
+  DATA_PTR(self) = hgcurve;
+#if 0
+  DATA_TYPE(self) = &siren_bzcurve_type;
+#endif
+  return self;
+}

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

@@ -0,0 +1,146 @@
+#include "curve.h"
+
+VALUE sr_cCircle;
+
+SR_CURVE_GET(Circle, circle)
+
+bool siren_circle_install()
+{
+  SR_CURVE_INIT(Circle)
+  rb_define_method(sr_cCircle, "initialize", RUBY_METHOD_FUNC(siren_curve_init),        -1);
+  rb_define_method(sr_cCircle, "radius",     RUBY_METHOD_FUNC(siren_circle_radius),     -1);
+  rb_define_method(sr_cCircle, "radius=",    RUBY_METHOD_FUNC(siren_circle_radius_set), -1);
+  rb_define_method(sr_cCircle, "center",     RUBY_METHOD_FUNC(siren_circle_center),     -1);
+  rb_define_method(sr_cCircle, "center=",    RUBY_METHOD_FUNC(siren_circle_center_set), -1);
+  rb_define_method(sr_cCircle, "area",       RUBY_METHOD_FUNC(siren_circle_area),       -1);
+  rb_define_method(sr_cCircle, "length",     RUBY_METHOD_FUNC(siren_circle_length),     -1);
+  rb_define_method(sr_cCircle, "normal",     RUBY_METHOD_FUNC(siren_circle_normal),     -1);
+  rb_define_method(sr_cCircle, "normal=",    RUBY_METHOD_FUNC(siren_circle_normal_set), -1);
+  rb_define_method(sr_cCircle, "dir",        RUBY_METHOD_FUNC(siren_circle_dir),        -1);
+  rb_define_method(sr_cCircle, "dir=",       RUBY_METHOD_FUNC(siren_circle_dir_set),    -1);
+  rb_define_method(sr_cCircle, "dist",       RUBY_METHOD_FUNC(siren_circle_dist),       -1);
+  rb_define_method(sr_cCircle, "distdist",   RUBY_METHOD_FUNC(siren_circle_distdist),   -1);
+  rb_define_method(sr_cCircle, "contain",    RUBY_METHOD_FUNC(siren_circle_contain),    -1);
+  return true;
+}
+
+VALUE siren_circle_radius(int argc, VALUE* argv, VALUE self)
+{
+  Standard_Real r = siren_circle_get(self)->Radius();
+  return (r);
+}
+
+VALUE siren_circle_radius_set(int argc, VALUE* argv, VALUE self)
+{
+  VALUE r;
+  rb_scan_args(argc, argv, "1", &r);
+  siren_circle_get(self)->SetRadius(r);
+  return Qnil;
+}
+
+VALUE siren_circle_center(int argc, VALUE* argv, VALUE self)
+{
+  gp_Pnt center = siren_circle_get(self)->Circ().Location();
+  return siren_pnt_to_ary(center);
+}
+
+VALUE siren_circle_center_set(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pos;
+  rb_scan_args(argc, argv, "1", &pos);
+  gp_Pnt p = siren_ary_to_pnt(pos);
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  gp_Circ circ = circle->Circ();
+  circ.SetLocation(p);
+  circle->SetCirc(circ);
+  return pos;
+}
+
+VALUE siren_circle_area(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  return (circle->Circ().Area());
+}
+
+VALUE siren_circle_length(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  return (circle->Circ().Length());
+}
+
+VALUE siren_circle_normal(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  // Returns the main axis of the circle.
+  // It is the axis perpendicular to the plane of the circle,
+  // passing through the "Location" point (center) of the circle.
+  gp_Ax1 axis = circle->Circ().Axis();
+  return siren_dir_to_ary(axis.Direction());
+}
+
+VALUE siren_circle_normal_set(int argc, VALUE* argv, VALUE self)
+{
+  VALUE norm;
+  rb_scan_args(argc, argv, "1", &norm);
+  gp_Dir dir = siren_ary_to_dir(norm);
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  gp_Circ circ = circle->Circ();
+  gp_Ax1 axis = circ.Axis();
+  axis.SetDirection(dir);
+  circ.SetAxis(axis);
+  circle->SetCirc(circ);
+  return norm;
+}
+
+VALUE siren_circle_dir(int argc, VALUE* argv, VALUE self)
+{
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  gp_Ax1 axis = circle->Circ().XAxis();
+  return siren_dir_to_ary(axis.Direction());
+}
+
+VALUE siren_circle_dir_set(int argc, VALUE* argv, VALUE self)
+{
+  VALUE val;
+  rb_scan_args(argc, argv, "1", &val);
+  gp_Dir dir = siren_ary_to_dir(val);
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  gp_Circ circ = circle->Circ();
+  gp_Ax2 axis;
+  axis.SetAxis(circ.Axis());
+  axis.SetXDirection(dir);
+  circ.SetPosition(axis);
+  circle->SetCirc(circ);
+  return val;
+}
+
+VALUE siren_circle_dist(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pos;
+  rb_scan_args(argc, argv, "1", &pos);
+  gp_Pnt p = siren_ary_to_pnt(pos);
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  gp_Circ circ = circle->Circ();
+  return (circ.Distance(p));
+}
+
+VALUE siren_circle_distdist(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pos;
+  rb_scan_args(argc, argv, "1", &pos);
+  gp_Pnt p = siren_ary_to_pnt(pos);
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  gp_Circ circ = circle->Circ();
+  return (circ.SquareDistance(p));
+}
+
+VALUE siren_circle_contain(int argc, VALUE* argv, VALUE self)
+{
+  VALUE pos;
+  VALUE lintol = 1.0e-7;
+  rb_scan_args(argc, argv, "11", &pos, &lintol);
+  gp_Pnt p = siren_ary_to_pnt(pos);
+  handle<Geom_Circle> circle = siren_circle_get(self);
+  gp_Circ circ = circle->Circ();
+  return circ.Contains(p, lintol) ? Qtrue : Qfalse;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * ellipse.cpp
+ * Implementation of singleton methods for ELLIPSE
+ */
+
+#include "curve.h"
+
+VALUE sr_cEllipse;
+
+SR_CURVE_GET(Ellipse, ellipse)
+
+bool siren_ellipse_install()
+{
+  SR_CURVE_INIT(Ellipse)
+  rb_define_method(sr_cEllipse, "initialize", RUBY_METHOD_FUNC(siren_curve_init), -1);
+  return true;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * hyperbola.cpp
+ * Implementation of singleton methods for HYPERBOLA
+ */
+
+#include "curve.h"
+
+VALUE sr_cHyperbola;
+
+SR_CURVE_GET(Hyperbola, hyperbola)
+
+bool siren_hyperbola_install()
+{
+  SR_CURVE_INIT(Hyperbola)
+  rb_define_method(sr_cHyperbola, "initialize", RUBY_METHOD_FUNC(siren_curve_init), -1);
+  return true;
+}