rcad 0.1.0 → 0.1.1

data/ext/_rcad/_rcad.cpp

@@ -1,3 +1,4 @@
+#include <sstream>
 #include <gp_Pnt2d.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Vec.hxx>
@@ -5,9 +6,11 @@
 #include <TColgp_Array2OfPnt.hxx>
 #include <Poly_Triangulation.hxx>
 #include <Geom_BezierSurface.hxx>
+#include <Geom_Circle.hxx>
 #include <GCE2d_MakeSegment.hxx>
 #include <TopoDS.hxx>
 #include <BRepPrimAPI_MakeBox.hxx>
+#include <BRepPrimAPI_MakeCone.hxx>
 #include <BRepPrimAPI_MakeCylinder.hxx>
 #include <BRepPrimAPI_MakeSphere.hxx>
 #include <BRepPrimAPI_MakeTorus.hxx>
@@ -29,6 +32,7 @@
 #include <BRepClass3d_SolidClassifier.hxx>
 #include <BRepTopAdaptor_FClass2d.hxx>
 #include <BRepMesh_IncrementalMesh.hxx>
+#include <BRepBndLib.hxx>
 #include <StlAPI_Reader.hxx>
 #include <StlAPI_Writer.hxx>
 #include <Standard_Failure.hxx>
@@ -86,17 +90,17 @@ gp_Pnt2d from_ruby<gp_Pnt2d>(Object obj)
 }
 
 template<>
-gp_Pnt from_ruby<gp_Pnt>(Object obj)
+gp_XYZ from_ruby<gp_XYZ>(Object obj)
 {
     Array ary(obj);
 
     if (ary.size() == 2) {
-        return gp_Pnt(
+        return gp_XYZ(
             from_ruby<Standard_Real>(ary[0]),
             from_ruby<Standard_Real>(ary[1]),
             0);
     } else if (ary.size() == 3) {
-        return gp_Pnt(
+        return gp_XYZ(
             from_ruby<Standard_Real>(ary[0]),
             from_ruby<Standard_Real>(ary[1]),
             from_ruby<Standard_Real>(ary[2]));
@@ -106,6 +110,12 @@ gp_Pnt from_ruby<gp_Pnt>(Object obj)
     }
 }
 
+template<>
+gp_Pnt from_ruby<gp_Pnt>(Object obj)
+{
+    return gp_Pnt(from_ruby<gp_XYZ>(obj));
+}
+
 template<>
 gp_Vec from_ruby<gp_Vec>(Object obj)
 {
@@ -128,85 +138,177 @@ gp_Dir from_ruby<gp_Dir>(Object obj)
     return gp_Dir(from_ruby<gp_Vec>(obj));
 }
 
-
-static Data_Object<TopoDS_Shape> render_shape(Object shape)
+template<>
+Object to_ruby<gp_Mat>(const gp_Mat &mat)
 {
-    if (shape.is_a(rb_cRenderedShape)) {
-        return shape;
-    }
+    Array mat_ary;
 
-    if (!shape.is_a(rb_cShape)) {
-        String shape_str = shape.to_s();
-        throw Exception(rb_eArgError,
-            "attempt to render %s which is not a Shape",
-            shape_str.c_str());
-    }
+    for (int i = 1; i <= 3; ++i) {
+        Array row_ary;
+        for (int j = 1; j <= 3; ++j) {
+            row_ary.push(mat(i, j));
+        }
 
-    while (shape.is_a(rb_cShape)) {
-        shape = shape.call("render");
+        mat_ary.push(row_ary);
     }
 
-    if (!shape.is_a(rb_cRenderedShape)) {
-        String shape_str = shape.to_s();
-        throw Exception(rb_eArgError,
-            "render returned %s instead of a rendered shape",
-            shape_str.c_str());
+    return mat_ary;
+}
+
+template<>
+Object to_ruby<gp_XYZ>(const gp_XYZ &xyz)
+{
+    Array ary;
+    ary.push(xyz.X());
+    ary.push(xyz.Y());
+    ary.push(xyz.Z());
+    return ary;
+}
+
+
+static Standard_Real get_tolerance()
+{
+    return from_ruby<Standard_Real>(
+        Object(rb_gv_get("$tol")));
+}
+
+
+static String transform_to_s(gp_GTrsf self)
+{
+    gp_Mat vec = self.VectorialPart();
+    gp_XYZ trn = self.TranslationPart();
+
+    std::stringstream s;
+    s << "#<Transform:";
+
+    for (int i = 1; i <= 3; ++i) {
+        for (int j = 1; j <= 3; ++j) {
+            s << vec(i, j)
+                << ((j < 3) ? ", " : "; ");
+        }
     }
 
-    return shape;
+    s << "x=" << trn.X()
+        << ", y=" << trn.Y()
+        << ", z=" << trn.Z();
+
+    s << ">";
+    return s.str();
 }
 
-static Object wrap_rendered_shape(const TopoDS_Shape &shape)
+static gp_Mat transform_mat_part(gp_GTrsf self)
 {
-    Object shape_obj = rb_cShape.call("new");
-    shape_obj.iv_set("@shape", to_ruby(shape));
-    return shape_obj;
+    return self.VectorialPart();
 }
 
-static Object shape_transform(Object self, const gp_Trsf &transform)
+static void transform_mat_part_set(gp_GTrsf &self, gp_Mat mat)
 {
-    Data_Object<TopoDS_Shape> rendered = render_shape(self);
-    return wrap_rendered_shape(
-        BRepBuilderAPI_Transform(*rendered, transform, Standard_True).Shape());
+    self.SetVectorialPart(mat);
 }
 
-Object shape_move(Object self, Standard_Real x, Standard_Real y,
-    Standard_Real z)
+static gp_XYZ transform_ofs_part(gp_GTrsf self)
 {
-    gp_Trsf transform;
-    transform.SetTranslation(gp_Vec(x, y, z));
-    return shape_transform(self, transform);
+    return self.TranslationPart();
 }
 
-Object shape_rotate(Object self, Standard_Real angle, gp_Dir axis)
+static void transform_ofs_part_set(gp_GTrsf &self, gp_XYZ ofs)
 {
-    gp_Trsf transform;
-    transform.SetRotation(gp_Ax1(gp_Pnt(), axis), angle);
-    return shape_transform(self, transform);
+    self.SetTranslationPart(ofs);
 }
 
-Object shape_scale(Object self, Standard_Real x, Standard_Real y,
+static gp_GTrsf transform_multiply(gp_GTrsf self, gp_GTrsf right)
+{
+    gp_GTrsf gtrsf = self;
+    gtrsf.Multiply(right);
+    return gtrsf;
+}
+
+static gp_GTrsf transform_move(gp_GTrsf self, Standard_Real x, Standard_Real y,
     Standard_Real z)
 {
-    gp_GTrsf transform;
-    transform.SetVectorialPart(
+    gp_GTrsf gtrsf;
+    gtrsf.SetTranslationPart(gp_XYZ(x, y, z));
+    gtrsf.Multiply(self);       // gtrsf *= self
+    return gtrsf;
+}
+
+static gp_GTrsf transform_rotate(gp_GTrsf self, Standard_Real angle,
+    gp_Dir axis)
+{
+    gp_Trsf rot;
+    rot.SetRotation(gp_Ax1(gp_Pnt(), axis), angle);
+
+    gp_GTrsf gtrsf(rot);
+    gtrsf.Multiply(self);       // gtrsf *= self
+    return gtrsf;
+}
+
+static gp_GTrsf transform_scale(gp_GTrsf self,
+    Standard_Real x, Standard_Real y, Standard_Real z)
+{
+    gp_GTrsf gtrsf;
+    gtrsf.SetVectorialPart(
         gp_Mat(x, 0, 0,
                0, y, 0,
                0, 0, z));
 
-    Data_Object<TopoDS_Shape> rendered = render_shape(self);
-    return wrap_rendered_shape(
-        BRepBuilderAPI_GTransform(*rendered, transform, Standard_True).Shape());
+    gtrsf.Multiply(self);       // gtrsf *= self
+    return gtrsf;
 }
 
-Object shape_mirror(Object self, Standard_Real x, Standard_Real y,
-    Standard_Real z)
+static gp_GTrsf transform_mirror(gp_GTrsf self,
+    Standard_Real x, Standard_Real y, Standard_Real z)
 {
     gp_Ax2 mirror_plane(gp::Origin(), gp_Dir(x, y, z));
 
-    gp_Trsf transform;
-    transform.SetMirror(mirror_plane);
-    return shape_transform(self, transform);
+    gp_Trsf mirror;
+    mirror.SetMirror(mirror_plane);
+
+    gp_GTrsf gtrsf(mirror);
+    gtrsf.Multiply(self);       // gtrsf *= self
+    return gtrsf;
+}
+
+static gp_GTrsf transform_inverse(gp_GTrsf self)
+{
+    gp_GTrsf gtrsf = self;
+    gtrsf.Invert();
+    return gtrsf;
+}
+
+
+static Data_Object<TopoDS_Shape> render_shape(Object shape)
+{
+    if (shape.is_a(rb_cRenderedShape)) {
+        return shape;
+    }
+
+    if (!shape.is_a(rb_cShape)) {
+        String shape_str = shape.to_s();
+        throw Exception(rb_eArgError,
+            "attempt to render %s which is not a Shape",
+            shape_str.c_str());
+    }
+
+    while (shape.is_a(rb_cShape)) {
+        shape = shape.call("render");
+    }
+
+    if (!shape.is_a(rb_cRenderedShape)) {
+        String shape_str = shape.to_s();
+        throw Exception(rb_eArgError,
+            "render returned %s instead of a rendered shape",
+            shape_str.c_str());
+    }
+
+    return shape;
+}
+
+// TODO: better to just put things in a Data_Object to begin with, than to
+// allocate them twice
+static Object wrap_rendered_shape(const TopoDS_Shape &shape)
+{
+    return Data_Object<TopoDS_Shape>(new TopoDS_Shape(shape));
 }
 
 void shape_write_stl(Object self, String path)
@@ -216,10 +318,34 @@ void shape_write_stl(Object self, String path)
     StlAPI_Writer writer;
     writer.ASCIIMode() = false;
     writer.RelativeMode() = false;
-    writer.SetDeflection(0.05);     // TODO: deflection param
+    writer.SetDeflection(get_tolerance());
     writer.Write(*shape, path.c_str());
 }
 
+Object shape__bbox(Object self)
+{
+    Data_Object<TopoDS_Shape> shape = render_shape(self);
+
+    Standard_Real minXYZ[3];
+    Standard_Real maxXYZ[3];
+    Bnd_Box bbox;
+    BRepBndLib::Add(*shape, bbox);
+    bbox.Get(
+        minXYZ[0], minXYZ[1], minXYZ[2],
+        maxXYZ[0], maxXYZ[1], maxXYZ[2]);
+    
+    const Standard_Real gap = bbox.GetGap();
+    for (int i = 0; i < 3; ++i) {
+        minXYZ[i] += gap;
+        maxXYZ[i] -= gap;
+    }
+
+    Array res;
+    res.push(Array(minXYZ));
+    res.push(Array(maxXYZ));
+    return res;
+}
+
 
 Object shape_from_stl(String path)
 {
@@ -230,6 +356,17 @@ Object shape_from_stl(String path)
 }
 
 
+Object transformed_shape_render(Object self)
+{
+    gp_GTrsf transform = from_ruby<gp_GTrsf>(self.iv_get("@trsf"));
+
+    Object shape = self.iv_get("@shape");
+    Data_Object<TopoDS_Shape> rendered = render_shape(shape);
+
+    return wrap_rendered_shape(
+        BRepBuilderAPI_GTransform(*rendered, transform, Standard_True).Shape());
+}
+
 static TopoDS_Wire make_wire_from_path(Array points, Array path)
 {
     BRepBuilderAPI_MakeWire wire_maker;
@@ -292,6 +429,16 @@ Object box_render(Object self)
 }
 
 
+Object cone_render(Object self)
+{
+    Standard_Real height = from_ruby<Standard_Real>(self.iv_get("@height"));
+    Standard_Real dia1 = from_ruby<Standard_Real>(self.iv_get("@bottom_dia"));
+    Standard_Real dia2 = from_ruby<Standard_Real>(self.iv_get("@top_dia"));
+    return to_ruby(
+        BRepPrimAPI_MakeCone(dia1 / 2.0, dia2 / 2.0, height).Shape());
+}
+
+
 Object cylinder_render(Object self)
 {
     Standard_Real height = from_ruby<Standard_Real>(self.iv_get("@height"));
@@ -420,50 +567,21 @@ static bool is_inner_wire_of_face(TopoDS_Wire wire, TopoDS_Face face)
     return (fclass2D.PerformInfinitePoint() != TopAbs_OUT);
 }
 
-static TopoDS_Shape twist_extrude_wire(TopoDS_Wire wire, Standard_Real height,
-    Standard_Real twist)
+static TopoDS_Shape extrude_wire(TopoDS_Wire profile, TopoDS_Wire spine,
+    TopoDS_Face spine_support)
 {
-    // split height into segments. each segment will twist no more than
-    // 90 degrees.
-    const int num_twist_segments = (int)(fabs(twist) / M_PI_2 + 1);
-    // note that height and twist are doubles so division is not integer
-    // division
-    const Standard_Real seg_height = height / num_twist_segments;
-    const Standard_Real seg_twist = twist / num_twist_segments;
-
-    Handle_Geom_BezierSurface surf_hnd(
-        new Geom_BezierSurface(
-            TColgp_Array2OfPnt(
-                1, num_twist_segments + 1,
-                1, 2)));
-
-    for (int i = 1; i <= num_twist_segments + 1; ++i) {
-        const Standard_Real z = seg_height * (i - 1);
-        const Standard_Real angle = seg_twist * (i - 1);
-        surf_hnd->SetPole(i, 1, gp_Pnt(0, 0, z));
-        surf_hnd->SetPole(i, 2, gp_Pnt(cos(angle), sin(angle), z));
-    }
-
-    TopoDS_Face spine_support =
-        // TODO: tolerance
-        BRepBuilderAPI_MakeFace(surf_hnd, 0, 1, 0, 1,
-            Precision::Confusion());
-
-    Handle_Geom2d_Curve uv_curve_hnd =
-        GCE2d_MakeSegment(gp_Pnt2d(0, 0), gp_Pnt2d(1, 0));
-    TopoDS_Edge spine = BRepBuilderAPI_MakeEdge(uv_curve_hnd, surf_hnd);
-    TopoDS_Wire spine_wire = BRepBuilderAPI_MakeWire(spine);
-
-
-    BRepOffsetAPI_MakePipeShell pipe_maker(spine_wire);
+    BRepOffsetAPI_MakePipeShell pipe_maker(spine);
 
-    if (!pipe_maker.SetMode(spine_support)) {
-        throw Exception(rb_cOCEError,
-            "failed setting twisted surface-normal for PipeShell");
+    if (!spine_support.IsNull()) {
+        if (!pipe_maker.SetMode(spine_support)) {
+            throw Exception(rb_cOCEError,
+                "failed setting twisted surface-normal for PipeShell");
+        }
     }
 
-    pipe_maker.Add(wire);
-    pipe_maker.SetTolerance(0.05, 0.05);        // TODO: tolerance
+    pipe_maker.Add(profile);
+    const Standard_Real tolerance = get_tolerance();
+    pipe_maker.SetTolerance(tolerance, tolerance);
     pipe_maker.Build();
 
     if (!pipe_maker.MakeSolid()) {
@@ -473,8 +591,8 @@ static TopoDS_Shape twist_extrude_wire(TopoDS_Wire wire, Standard_Real height,
     return pipe_maker.Shape();
 }
 
-static TopoDS_Shape twist_extrude_face(TopoDS_Face face, Standard_Real height,
-    Standard_Real twist)
+static TopoDS_Shape extrude_face(TopoDS_Face profile, TopoDS_Wire spine,
+    TopoDS_Face spine_support)
 {
     // extrude outer and inner wires separately, then subtract the inner
     // shapes from the outer shape. there should be only one outer shape,
@@ -488,10 +606,10 @@ static TopoDS_Shape twist_extrude_face(TopoDS_Face face, Standard_Real height,
 
     TopExp_Explorer texp;
 
-    TopoDS_Face orface = TopoDS::Face(face.Oriented(TopAbs_FORWARD));
+    TopoDS_Face orface = TopoDS::Face(profile.Oriented(TopAbs_FORWARD));
     for (texp.Init(orface, TopAbs_WIRE); texp.More(); texp.Next()) {
         TopoDS_Wire wire = TopoDS::Wire(texp.Current());
-        TopoDS_Shape ext_wire = twist_extrude_wire(wire, height, twist);
+        TopoDS_Shape ext_wire = extrude_wire(wire, spine, spine_support);
 
         if (is_inner_wire_of_face(wire, orface)) {
             builder.Add(inner, ext_wire);
@@ -503,6 +621,60 @@ static TopoDS_Shape twist_extrude_face(TopoDS_Face face, Standard_Real height,
     return BRepAlgoAPI_Cut(outer, inner).Shape();
 }
 
+static TopoDS_Shape extrude_shape(TopoDS_Shape profile, TopoDS_Wire spine,
+    TopoDS_Face spine_support)
+{
+    BRep_Builder builder;
+    TopoDS_Compound compound;
+    builder.MakeCompound(compound);
+
+    TopExp_Explorer texp;
+    for (texp.Init(profile, TopAbs_FACE); texp.More(); texp.Next()) {
+        builder.Add(compound,
+            extrude_face(
+                TopoDS::Face(texp.Current()), spine, spine_support));
+    }
+
+    return compound;
+}
+
+static TopoDS_Shape twist_extrude(TopoDS_Shape shape, Standard_Real height,
+    Standard_Real twist)
+{
+    // split height into segments. each segment will twist no more than
+    // 90 degrees.
+    const int num_twist_segments = (int)(fabs(twist) / M_PI_2 + 1);
+    // note that height and twist are doubles so division is not integer
+    // division
+    const Standard_Real seg_height = height / num_twist_segments;
+    const Standard_Real seg_twist = twist / num_twist_segments;
+
+    Handle_Geom_BezierSurface surf_hnd(
+        new Geom_BezierSurface(
+            TColgp_Array2OfPnt(
+                1, num_twist_segments + 1,
+                1, 2)));
+
+    for (int i = 1; i <= num_twist_segments + 1; ++i) {
+        const Standard_Real z = seg_height * (i - 1);
+        const Standard_Real angle = seg_twist * (i - 1);
+        surf_hnd->SetPole(i, 1, gp_Pnt(0, 0, z));
+        surf_hnd->SetPole(i, 2, gp_Pnt(cos(angle), sin(angle), z));
+    }
+
+    TopoDS_Face spine_support =
+        // TODO: tolerance
+        BRepBuilderAPI_MakeFace(surf_hnd, 0, 1, 0, 1,
+            Precision::Confusion());
+
+    Handle_Geom2d_Curve uv_curve_hnd =
+        GCE2d_MakeSegment(gp_Pnt2d(0, 0), gp_Pnt2d(1, 0));
+    TopoDS_Edge spine = BRepBuilderAPI_MakeEdge(uv_curve_hnd, surf_hnd);
+    TopoDS_Wire spine_wire = BRepBuilderAPI_MakeWire(spine);
+
+    return extrude_shape(shape, spine_wire, spine_support);
+}
+
 // initialize is defined in Ruby code
 Object linear_extrusion_render(Object self)
 {
@@ -517,38 +689,35 @@ Object linear_extrusion_render(Object self)
             BRepPrimAPI_MakePrism(*shape, gp_Vec(0, 0, height),
                 Standard_True).Shape());
     } else {
-        BRep_Builder builder;
-        TopoDS_Compound compound;
-        builder.MakeCompound(compound);
-
-        TopExp_Explorer texp;
-        for (texp.Init(*shape, TopAbs_FACE); texp.More(); texp.Next()) {
-            builder.Add(compound,
-                twist_extrude_face(
-                    TopoDS::Face(texp.Current()), height, twist));
-        }
-
-        return wrap_rendered_shape(compound);
+        return wrap_rendered_shape(twist_extrude(*shape, height, twist));
     }
 }
 
 
-// initialize is defined in Ruby code
 Object revolution_render(Object self)
 {
     Object profile = self.iv_get("@profile");
     Data_Object<TopoDS_Shape> shape = render_shape(profile);
 
     Object angle = self.iv_get("@angle");
+
+    gp_Circ circ(gp_Ax2(gp::Origin(), -gp::DY(), gp::DX()), 1.0);
+    TopoDS_Edge edge;
+
     if (angle.is_nil()) {
-        return to_ruby(
-            BRepPrimAPI_MakeRevol(*shape, gp::OY(), Standard_True).Shape());
+        edge = BRepBuilderAPI_MakeEdge(circ);
     } else {
         Standard_Real angle_num = from_ruby<Standard_Real>(angle);
-        return to_ruby(
-            BRepPrimAPI_MakeRevol(*shape, gp::OY(), angle_num,
-                Standard_True).Shape());
+        angle_num = std::max(angle_num, 0.0);
+        angle_num = std::min(angle_num, M_PI * 2);
+
+        Handle_Geom_Curve curve_hnd(new Geom_Circle(circ));
+        edge = BRepBuilderAPI_MakeEdge(curve_hnd, 0, angle_num);
     }
+
+    TopoDS_Wire spine = BRepBuilderAPI_MakeWire(edge);
+    return wrap_rendered_shape(
+        extrude_shape(*shape, spine, TopoDS_Face()));
 }
 
 
@@ -581,11 +750,13 @@ static std::vector<gp_Pnt> get_points_from_shapes(Array shapes)
 {
     std::vector<gp_Pnt> points;
 
+    const Standard_Real tolerance = get_tolerance();
+
     for (size_t i = 0; i < shapes.size(); ++i) {
         Data_Object<TopoDS_Shape> shape_obj = render_shape(shapes[i]);
         const TopoDS_Shape &shape = *shape_obj;
 
-        BRepMesh_IncrementalMesh(shape, 0.05);      // TODO: tolerance
+        BRepMesh_IncrementalMesh(shape, tolerance);
 
         get_points_from_shape(shape, points);
     }
@@ -594,13 +765,13 @@ static std::vector<gp_Pnt> get_points_from_shapes(Array shapes)
 }
 
 
-// Sort function object to sort polygon vertices
+// Sort function object to sort the vertices of a convex polygon
 // Algorithm from here:
 // http://stackoverflow.com/a/15104911/2758814
-class PolygonVertexSortComparator
+class ConvexPolygonVertexSortComparator
 {
 public:
-    PolygonVertexSortComparator(std::vector<gp_Pnt> vertices)
+    ConvexPolygonVertexSortComparator(std::vector<gp_Pnt> vertices)
         : vertices(vertices)
     {
         if (vertices.size() == 0) {
@@ -673,7 +844,7 @@ static TopoDS_Solid make_solid_from_qhull()
         }
 
         sort(vertices.begin(), vertices.end(),
-            PolygonVertexSortComparator(vertices));
+            ConvexPolygonVertexSortComparator(vertices));
 
         BRepBuilderAPI_MakePolygon poly_maker;
         for (size_t i = 0; i < vertices.size(); ++i) {
@@ -734,21 +905,38 @@ static Object _hull(Array shapes)
 extern "C"
 void Init__rcad()
 {
-    Data_Type<TopoDS_Shape> rb_cRenderedShape =
-        define_class<TopoDS_Shape>("RenderedShape");
+    rb_cRenderedShape = define_class<TopoDS_Shape>("RenderedShape");
 
     Data_Type<Standard_Failure> rb_cOCEError =
         define_class("OCEError", rb_eRuntimeError);
 
+    Class rb_cTransform = define_class<gp_GTrsf>("Transform")
+        .add_handler<Standard_Failure>(translate_oce_exception)
+        .define_method("to_s", &transform_to_s)
+        .define_method("mat_part", &transform_mat_part)
+        .define_method("mat_part=", &transform_mat_part_set)
+        .define_method("ofs_part", &transform_ofs_part)
+        .define_method("ofs_part=", &transform_ofs_part_set)
+        .define_method("*", &transform_multiply)
+        .define_method("move", &transform_move)
+        .define_method("rotate", &transform_rotate)
+        .define_method("scale", &transform_scale)
+        .define_method("mirror", &transform_mirror)
+        .define_method("inverse", &transform_inverse);
+
+    rb_const_set(rb_cObject, Identifier("I"), to_ruby<gp_GTrsf>(gp_GTrsf()));
+
+
     rb_cShape = define_class("Shape")
         .add_handler<Standard_Failure>(translate_oce_exception)
-        .define_method("move", &shape_move)
-        .define_method("rotate", &shape_rotate)
-        .define_method("scale", &shape_scale)
-        .define_method("mirror", &shape_mirror)
         .define_method("write_stl", &shape_write_stl)
+        .define_method("_bbox", &shape__bbox)
         .define_singleton_method("from_stl", &shape_from_stl);
 
+    Class rb_cTransformedShape = define_class("TransformedShape", rb_cShape)
+        .add_handler<Standard_Failure>(translate_oce_exception)
+        .define_method("render", &transformed_shape_render);
+
     Class rb_cPolygon = define_class("Polygon", rb_cShape)
         .add_handler<Standard_Failure>(translate_oce_exception)
         .define_method("render", &polygon_render);
@@ -762,6 +950,10 @@ void Init__rcad()
         .add_handler<Standard_Failure>(translate_oce_exception)
         .define_method("render", &box_render);
 
+    Class rb_cCone = define_class("Cone", rb_cShape)
+        .add_handler<Standard_Failure>(translate_oce_exception)
+        .define_method("render", &cone_render);
+
     Class rb_cCylinder = define_class("Cylinder", rb_cShape)
         .add_handler<Standard_Failure>(translate_oce_exception)
         .define_method("render", &cylinder_render);

data/lib/rcad.rb

@@ -29,12 +29,64 @@ class Numeric
 end
 
 
+# global tolerance value used by C++ extension when rendering shapes
+$tol = 50.um
+
+
 def to_polar(r, a)
   return [r * Math::cos(a), r * Math::sin(a)]
 end
 
 
-TOLERANCE = 50.um
+class Transform
+  def move_x(delta)
+    move(delta, 0, 0)
+  end
+
+  def move_y(delta)
+    move(0, delta, 0)
+  end
+
+  def move_z(delta)
+    move(0, 0, delta)
+  end
+
+  def rot_x(angle)
+    rotate(angle, [1, 0, 0])
+  end
+
+  def rot_y(angle)
+    rotate(angle, [0, 1, 0])
+  end
+
+  def rot_z(angle)
+    rotate(angle, [0, 0, 1])
+  end
+
+  def scale_x(factor)
+    scale(factor, 1, 1)
+  end
+
+  def scale_y(factor)
+    scale(1, factor, 1)
+  end
+
+  def scale_z(factor)
+    scale(1, 1, factor)
+  end
+
+  def mirror_x
+    mirror(1, 0, 0)
+  end
+
+  def mirror_y
+    mirror(0, 1, 0)
+  end
+
+  def mirror_z
+    mirror(0, 0, 1)
+  end
+end
 
 
 class Shape
@@ -63,9 +115,30 @@ class Shape
       $shape = ($shape == nil) ? self : $shape.send($shape_mode, self)
     end
 
+    p self
     self
   end
 
+  def transform(trsf)
+    TransformedShape.new(self, trsf)
+  end
+
+  def move(x, y, z)
+    TransformedShape.new(self, I.move(x, y, z))
+  end
+
+  def rotate(angle, axis)
+    TransformedShape.new(self, I.rotate(angle, axis))
+  end
+
+  def scale(x, y, z)
+    TransformedShape.new(self, I.scale(x, y, z))
+  end
+
+  def mirror(x, y, z)
+    TransformedShape.new(self, I.mirror(x, y, z))
+  end
+
   def move_x(delta)
     move(delta, 0, 0)
   end
@@ -118,48 +191,120 @@ class Shape
     LinearExtrusion.new(self, height, twist)
   end
 
-  def revolve(angle=360.deg_to_rad)
+  def revolve(angle=nil)
     Revolution.new(self, angle)
   end
 
   def bbox
-    # TODO
+    if @bbox == nil
+      @bbox = _bbox
+    end
+
+    @bbox
+  end
+
+  def minx
+    bbox[0][0]
   end
 
-  def min_x
-    bbox[0].x
+  def miny
+    bbox[0][1]
   end
 
-  def min_y
-    bbox[0].y
+  def minz
+    bbox[0][2]
   end
 
-  def min_z
-    bbox[0].z
+  def maxx
+    bbox[1][0]
   end
 
-  def max_x
-    bbox[1].x
+  def maxy
+    bbox[1][1]
   end
 
-  def max_y
-    bbox[1].y
+  def maxz
+    bbox[1][2]
   end
 
-  def max_z
-    bbox[1].z
+  def xsize
+    maxx - minx
   end
 
-  def x_size
-    max_x - min_x
+  def ysize
+    maxy - miny
   end
 
-  def y_size
-    max_y - min_y
+  def zsize
+    maxz - minz
   end
 
-  def z_size
-    max_z - min_z
+  def cx
+    (minx + maxx) / 2.0
+  end
+
+  def cy
+    (miny + maxy) / 2.0
+  end
+
+  def cz
+    (minz + maxz) / 2.0
+  end
+
+  def left
+    I.move_x(minx)
+  end
+
+  def right
+    I.move_x(maxx)
+  end
+
+  def front
+    I.move_y(miny)
+  end
+
+  def back
+    I.move_y(maxy)
+  end
+
+  def top
+    I.move_z(maxz)
+  end
+
+  def bottom
+    I.move_z(minz)
+  end
+
+  def xcenter
+    I.move_x(cx)
+  end
+
+  def ycenter
+    I.move_y(cy)
+  end
+
+  def zcenter
+    I.move_z(cz)
+  end
+
+  def center
+    I.move(cx, cy, cz)
+  end
+
+  def align(*align_pts)
+    at = align_pts.pop
+
+    if align_pts.empty?
+      return self.transform(at)
+    end
+
+    combined = align_pts
+      .map { |apt| (apt.is_a? Transform) ? apt : self.send(apt) }
+      .reduce :*
+
+    combined = (yield self) * combined if block_given?
+
+    self.transform(at * combined.inverse)
   end
 end
 
@@ -221,7 +366,41 @@ at_exit do
 end
 
 
-class Polygon
+class TransformedShape < Shape
+  attr_reader :shape, :trsf
+
+  def initialize(shape, trsf)
+    @shape = shape
+    @trsf = trsf
+  end
+
+  def to_s
+    sprintf("%s*%s", @trsf, @shape)
+  end
+
+  def transform(trsf)
+    TransformedShape.new(@shape, trsf * @trsf)
+  end
+
+  def move(x, y, z)
+    TransformedShape.new(@shape, @trsf.move(x, y, z))
+  end
+
+  def rotate(angle, axis)
+    TransformedShape.new(@shape, @trsf.rotate(angle, axis))
+  end
+
+  def scale(x, y, z)
+    TransformedShape.new(@shape, @trsf.scale(x, y, z))
+  end
+
+  def mirror(x, y, z)
+    TransformedShape.new(@shape, @trsf.mirror(x, y, z))
+  end
+end
+
+
+class Polygon < Shape
   attr_reader :points, :paths
 
   def initialize(points, paths=nil)
@@ -245,13 +424,26 @@ class RegularPolygon < Polygon
 end
 
 
-class Square < Polygon
+class Rectangle < Polygon
+  # These override Shape.xsize etc.
+  attr_reader :xsize, :ysize
+
+  def initialize(xsize, ysize)
+    @xsize = xsize
+    @ysize = ysize
+
+    super([[0,0], [xsize,0], [xsize,ysize], [0,ysize]])
+  end
+end
+
+
+class Square < Rectangle
   attr_reader :size
 
   def initialize(size)
     @size = size
 
-    super([[0,0], [size,0], [size,size], [0,size]])
+    super(size, size)
   end
 end
 
@@ -271,6 +463,7 @@ end
 
 
 class Box < Shape
+  # These override Shape.xsize etc.
   attr_accessor :xsize, :ysize, :zsize
 
   def initialize(xsize, ysize, zsize)
@@ -287,6 +480,25 @@ class Cube < Box
 end
 
 
+class Cone < Shape
+  attr_accessor :height, :bottom_dia, :top_dia
+
+  def initialize(height, bottom_dia, top_dia=0)
+    @height = height
+    @bottom_dia = bottom_dia
+    @top_dia = top_dia
+  end
+
+  def bottom_radius
+    bottom_dia / 2.0
+  end
+
+  def top_radius
+    top_dia / 2.0
+  end
+end
+
+
 class Cylinder < Shape
   attr_accessor :height, :dia
 
@@ -383,12 +595,14 @@ end
 
 make_maker :polygon, Polygon
 make_maker :reg_poly, RegularPolygon
+make_maker :rectangle, Rectangle
 make_maker :square, Square
 make_maker :circle, Circle
 make_maker :text, Text
 
 make_maker :box, Box
 make_maker :cube, Cube
+make_maker :cone, Cone
 make_maker :cylinder, Cylinder
 make_maker :sphere, Sphere
 make_maker :polyhedron, Polyhedron

data/lib/rcad/version.rb

@@ -1,3 +1,3 @@
 module Rcad
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcad
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-03 00:00:00.000000000 Z
+date: 2013-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler