More NR::Point ==> Geom::Point

diff --git a/src/box3d-context.cpp b/src/box3d-context.cpp
index 0ea8b1dbdaed1679968874177f0147ca188c3c7e..03a9073b4c564229c9c5d9349586a345d5a76671 100644 (file)
--- a/src/box3d-context.cpp
+++ b/src/box3d-context.cpp
@@ -302,12 +302,12 @@ static gint sp_box3d_context_root_handler(SPEventContext *event_context, GdkEven
     switch (event->type) {
     case GDK_BUTTON_PRESS:
         if ( event->button.button == 1  && !event_context->space_panning) {
-            NR::Point const button_w(event->button.x,
-                                     event->button.y);
+            Geom::Point const button_w(event->button.x,
+                                       event->button.y);
 
             // save drag origin
-            event_context->xp = (gint) button_w[NR::X];
-            event_context->yp = (gint) button_w[NR::Y];
+            event_context->xp = (gint) button_w[Geom::X];
+            event_context->yp = (gint) button_w[Geom::Y];
             event_context->within_tolerance = true;
             
             // remember clicked item, *not* disregarding groups (since a 3D box is a group), honoring Alt
@@ -357,9 +357,9 @@ static gint sp_box3d_context_root_handler(SPEventContext *event_context, GdkEven
             // motion notify coordinates as given (no snapping back to origin)
             event_context->within_tolerance = false;
 
-            NR::Point const motion_w(event->motion.x,
-                                     event->motion.y);
-            Geom::Point motion_dt(to_2geom(desktop->w2d(motion_w)));
+            Geom::Point const motion_w(event->motion.x,
+                                       event->motion.y);
+            Geom::Point motion_dt(desktop->w2d(motion_w));
 
             SnapManager &m = desktop->namedview->snap_manager;
             m.setup(desktop, true, bc->item);

diff --git a/src/box3d-context.h b/src/box3d-context.h
index 3432a1a5b899d0005d6238da8ddca23e13c09a39..8bafa75f2f4e41f46b89694789db26cd7ff44315 100644 (file)
--- a/src/box3d-context.h
+++ b/src/box3d-context.h
@@ -31,7 +31,7 @@ class Box3DContextClass;
 
 struct Box3DContext : public SPEventContext {
     SPItem *item;
-    NR::Point center;
+    Geom::Point center;
 
     /**
      * save three corners while dragging:
@@ -41,9 +41,9 @@ struct Box3DContext : public SPEventContext {
      *    if we are ctrl-dragging but is constrained to the perspective line from drag_ptC
      *    to the vanishing point Y otherwise)
      */
-    NR::Point drag_origin;
-    NR::Point drag_ptB;
-    NR::Point drag_ptC;
+    Geom::Point drag_origin;
+    Geom::Point drag_ptB;
+    Geom::Point drag_ptC;
 
     Proj::Pt3 drag_origin_proj;
     Proj::Pt3 drag_ptB_proj;

diff --git a/src/box3d.cpp b/src/box3d.cpp
index a517ea0a2cbb7c669eb6038c02909595764f5ca5..6f4253cab8683046f350e5eb6637637b6cdcd46b 100644 (file)
--- a/src/box3d.cpp
+++ b/src/box3d.cpp
@@ -403,13 +403,13 @@ box3d_get_proj_corner (SPBox3D const *box, guint id) {
                       1.0);
 }
 
-NR::Point
+Geom::Point
 box3d_get_corner_screen (SPBox3D const *box, guint id, bool item_coords) {
     Proj::Pt3 proj_corner (box3d_get_proj_corner (box, id));
     if (!box3d_get_perspective(box)) {
-        return NR::Point (NR_HUGE, NR_HUGE);
+        return Geom::Point (NR_HUGE, NR_HUGE);
     }
-    NR::Matrix const i2d (sp_item_i2d_affine (SP_ITEM(box)));
+    Geom::Matrix const i2d (sp_item_i2d_affine (SP_ITEM(box)));
     if (item_coords) {
         return box3d_get_perspective(box)->tmat.image(proj_corner).affine() * i2d.inverse();
     } else {
@@ -427,13 +427,13 @@ box3d_get_proj_center (SPBox3D *box) {
                       1.0);
 }
 
-NR::Point
+Geom::Point
 box3d_get_center_screen (SPBox3D *box) {
     Proj::Pt3 proj_center (box3d_get_proj_center (box));
     if (!box3d_get_perspective(box)) {
-        return NR::Point (NR_HUGE, NR_HUGE);
+        return Geom::Point (NR_HUGE, NR_HUGE);
     }
-    NR::Matrix const i2d (sp_item_i2d_affine (SP_ITEM(box)));
+    Geom::Matrix const i2d (sp_item_i2d_affine (SP_ITEM(box)));
     return box3d_get_perspective(box)->tmat.image(proj_center).affine() * i2d.inverse();
 }
 
@@ -461,12 +461,12 @@ box3d_snap (SPBox3D *box, int id, Proj::Pt3 const &pt_proj, Proj::Pt3 const &sta
     Proj::Pt3 E_proj (x_coord - diff_x, y_coord + diff_y, z_coord, 1.0);
 
     Persp3D *persp = box3d_get_perspective(box);
-    NR::Point A = persp->tmat.image(A_proj).affine();
-    NR::Point B = persp->tmat.image(B_proj).affine();
-    NR::Point C = persp->tmat.image(C_proj).affine();
-    NR::Point D = persp->tmat.image(D_proj).affine();
-    NR::Point E = persp->tmat.image(E_proj).affine();
-    NR::Point pt = persp->tmat.image(pt_proj).affine();
+    Geom::Point A = persp->tmat.image(A_proj).affine();
+    Geom::Point B = persp->tmat.image(B_proj).affine();
+    Geom::Point C = persp->tmat.image(C_proj).affine();
+    Geom::Point D = persp->tmat.image(D_proj).affine();
+    Geom::Point E = persp->tmat.image(E_proj).affine();
+    Geom::Point pt = persp->tmat.image(pt_proj).affine();
 
     // TODO: Replace these lines between corners with lines from a corner to a vanishing point
     //       (this might help to prevent rounding errors if the box is small)
@@ -476,7 +476,7 @@ box3d_snap (SPBox3D *box, int id, Proj::Pt3 const &pt_proj, Proj::Pt3 const &sta
     Box3D::Line diag2(A, E); // diag2 is only taken into account if id equals -1, i.e., if we are snapping the center
 
     int num_snap_lines = (id != -1) ? 3 : 4;
-    NR::Point snap_pts[num_snap_lines];
+    Geom::Point snap_pts[num_snap_lines];
 
     snap_pts[0] = pl1.closest_to (pt);
     snap_pts[1] = pl2.closest_to (pt);
@@ -515,7 +515,7 @@ box3d_snap (SPBox3D *box, int id, Proj::Pt3 const &pt_proj, Proj::Pt3 const &sta
 
     // snap to the closest point (or the previously remembered one
     // if we are within tolerance of the starting point)
-    NR::Point result;
+    Geom::Point result;
     if (within_tolerance) {
         result = snap_pts[remember_snap_index];
     } else {
@@ -526,7 +526,7 @@ box3d_snap (SPBox3D *box, int id, Proj::Pt3 const &pt_proj, Proj::Pt3 const &sta
 }
 
 void
-box3d_set_corner (SPBox3D *box, const guint id, NR::Point const &new_pos, const Box3D::Axis movement, bool constrained) {
+box3d_set_corner (SPBox3D *box, const guint id, Geom::Point const &new_pos, const Box3D::Axis movement, bool constrained) {
     g_return_if_fail ((movement != Box3D::NONE) && (movement != Box3D::XYZ));
 
     box->orig_corner0.normalize();
@@ -555,7 +555,7 @@ box3d_set_corner (SPBox3D *box, const guint id, NR::Point const &new_pos, const
         Box3D::PerspectiveLine pl(persp->tmat.image(
                                       box3d_get_proj_corner (id, box->save_corner0, box->save_corner7)).affine(),
                                   Proj::Z, persp);
-        NR::Point new_pos_snapped(pl.closest_to(new_pos));
+        Geom::Point new_pos_snapped(pl.closest_to(new_pos));
         Proj::Pt3 pt_proj (persp->tmat.preimage (new_pos_snapped,
                                           box3d_get_proj_corner (box, id)[(movement & Box3D::Y) ? Proj::X : Proj::Y],
                                           (movement & Box3D::Y) ? Proj::X : Proj::Y));
@@ -577,7 +577,7 @@ box3d_set_corner (SPBox3D *box, const guint id, NR::Point const &new_pos, const
     // FIXME: Should we update the box here? If so, how?
 }
 
-void box3d_set_center (SPBox3D *box, NR::Point const &new_pos, NR::Point const &old_pos, const Box3D::Axis movement, bool constrained) {
+void box3d_set_center (SPBox3D *box, Geom::Point const &new_pos, Geom::Point const &old_pos, const Box3D::Axis movement, bool constrained) {
     g_return_if_fail ((movement != Box3D::NONE) && (movement != Box3D::XYZ));
 
     box->orig_corner0.normalize();
@@ -610,7 +610,7 @@ void box3d_set_center (SPBox3D *box, NR::Point const &new_pos, NR::Point const &
         double radz = (box->orig_corner7[Proj::Z] - box->orig_corner0[Proj::Z]) / 2;
 
         Box3D::PerspectiveLine pl(old_pos, Proj::Z, persp);
-        NR::Point new_pos_snapped(pl.closest_to(new_pos));
+        Geom::Point new_pos_snapped(pl.closest_to(new_pos));
         Proj::Pt3 pt_proj (persp->tmat.preimage (new_pos_snapped, coord, Proj::X));
 
         /* normalizing pt_proj is essential because we want to mingle affine coordinates */
@@ -631,7 +631,7 @@ void box3d_set_center (SPBox3D *box, NR::Point const &new_pos, NR::Point const &
  * from which the perspective lines in the direction of 'axis' emerge
  */
 void box3d_corners_for_PLs (const SPBox3D * box, Proj::Axis axis,
-                            NR::Point &corner1, NR::Point &corner2, NR::Point &corner3, NR::Point &corner4)
+                            Geom::Point &corner1, Geom::Point &corner2, Geom::Point &corner3, Geom::Point &corner4)
 {
     Persp3D *persp = box3d_get_perspective(box);
     g_return_if_fail (persp);
@@ -708,8 +708,8 @@ box3d_XY_axes_are_swapped (SPBox3D *box) {
     g_return_val_if_fail(persp, false);
     Box3D::PerspectiveLine l1(box3d_get_corner_screen(box, 3, false), Proj::X, persp);
     Box3D::PerspectiveLine l2(box3d_get_corner_screen(box, 3, false), Proj::Y, persp);
-    NR::Point v1(l1.direction());
-    NR::Point v2(l2.direction());
+    Geom::Point v1(l1.direction());
+    Geom::Point v2(l2.direction());
     v1.normalize();
     v2.normalize();
 
@@ -750,9 +750,9 @@ box3d_swap_z_orders (int z_orders[6]) {
 static void
 box3d_set_new_z_orders_case0 (SPBox3D *box, int z_orders[6], Box3D::Axis central_axis) {
     Persp3D *persp = box3d_get_perspective(box);
-    NR::Point xdir(persp3d_get_infinite_dir(persp, Proj::X));
-    NR::Point ydir(persp3d_get_infinite_dir(persp, Proj::Y));
-    NR::Point zdir(persp3d_get_infinite_dir(persp, Proj::Z));
+    Geom::Point xdir(persp3d_get_infinite_dir(persp, Proj::X));
+    Geom::Point ydir(persp3d_get_infinite_dir(persp, Proj::Y));
+    Geom::Point zdir(persp3d_get_infinite_dir(persp, Proj::Z));
 
     bool swapped = box3d_XY_axes_are_swapped(box);
 
@@ -795,7 +795,7 @@ box3d_set_new_z_orders_case0 (SPBox3D *box, int z_orders[6], Box3D::Axis central
 static void
 box3d_set_new_z_orders_case1 (SPBox3D *box, int z_orders[6], Box3D::Axis central_axis, Box3D::Axis fin_axis) {
     Persp3D *persp = box3d_get_perspective(box);
-    NR::Point vp(persp3d_get_VP(persp, Box3D::toProj(fin_axis)).affine());
+    Geom::Point vp(persp3d_get_VP(persp, Box3D::toProj(fin_axis)).affine());
 
     // note: in some of the case distinctions below we rely upon the fact that oaxis1 and oaxis2 are ordered
     Box3D::Axis oaxis1 = Box3D::get_remaining_axes(fin_axis).first;
@@ -867,10 +867,10 @@ static void
 box3d_set_new_z_orders_case2 (SPBox3D *box, int z_orders[6], Box3D::Axis central_axis, Box3D::Axis /*infinite_axis*/) {
     Persp3D *persp = box3d_get_perspective(box);
 
-    NR::Point c3(box3d_get_corner_screen(box, 3, false));
-    NR::Point xdir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::X));
-    NR::Point ydir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::Y));
-    NR::Point zdir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::Z));
+    Geom::Point c3(box3d_get_corner_screen(box, 3, false));
+    Geom::Point xdir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::X));
+    Geom::Point ydir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::Y));
+    Geom::Point zdir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::Z));
 
     bool swapped = box3d_XY_axes_are_swapped(box);
 
@@ -1002,13 +1002,13 @@ box3d_recompute_z_orders (SPBox3D *box) {
 
     int z_orders[6];
 
-    NR::Point c3(box3d_get_corner_screen(box, 3, false));
+    Geom::Point c3(box3d_get_corner_screen(box, 3, false));
 
     // determine directions from corner3 to the VPs
     int num_finite = 0;
     Box3D::Axis axis_finite = Box3D::NONE;
     Box3D::Axis axis_infinite = Box3D::NONE;
-    NR::Point dirs[3];
+    Geom::Point dirs[3];
     for (int i = 0; i < 3; ++i) {
         dirs[i] = persp3d_get_PL_dir_from_pt(persp, c3, Box3D::toProj(Box3D::axes[i]));
         if (persp3d_VP_is_finite(persp, Proj::axes[i])) {
@@ -1048,16 +1048,16 @@ box3d_recompute_z_orders (SPBox3D *box) {
          * joining the other two VPs. If this is the case, it determines the "central" corner from
          * which the visible sides can be deduced. Otherwise, corner3 is the central corner.
          */
-        // FIXME: We should eliminate the use of NR::Point altogether
+        // FIXME: We should eliminate the use of Geom::Point altogether
         Box3D::Axis central_axis = Box3D::NONE;
-        NR::Point vp_x = persp3d_get_VP(persp, Proj::X).affine();
-        NR::Point vp_y = persp3d_get_VP(persp, Proj::Y).affine();
-        NR::Point vp_z = persp3d_get_VP(persp, Proj::Z).affine();
+        Geom::Point vp_x = persp3d_get_VP(persp, Proj::X).affine();
+        Geom::Point vp_y = persp3d_get_VP(persp, Proj::Y).affine();
+        Geom::Point vp_z = persp3d_get_VP(persp, Proj::Z).affine();
         Geom::Point vpx(vp_x[NR::X], vp_x[NR::Y]);
         Geom::Point vpy(vp_y[NR::X], vp_y[NR::Y]);
         Geom::Point vpz(vp_z[NR::X], vp_z[NR::Y]);
 
-        NR::Point c3 = box3d_get_corner_screen(box, 3, false);
+        Geom::Point c3 = box3d_get_corner_screen(box, 3, false);
         Geom::Point corner3(c3[NR::X], c3[NR::Y]);
 
         if (box3d_half_line_crosses_joining_line (corner3, vpx, vpy, vpz)) {
@@ -1076,9 +1076,9 @@ box3d_recompute_z_orders (SPBox3D *box) {
             central_corner = central_corner ^ Box3D::XYZ;
         }
 
-        NR::Point c1(box3d_get_corner_screen(box, 1, false));
-        NR::Point c2(box3d_get_corner_screen(box, 2, false));
-        NR::Point c7(box3d_get_corner_screen(box, 7, false));
+        Geom::Point c1(box3d_get_corner_screen(box, 1, false));
+        Geom::Point c2(box3d_get_corner_screen(box, 2, false));
+        Geom::Point c7(box3d_get_corner_screen(box, 7, false));
 
         Geom::Point corner1(c1[NR::X], c1[NR::Y]);
         Geom::Point corner2(c2[NR::X], c2[NR::Y]);
@@ -1188,19 +1188,19 @@ box3d_set_z_orders (SPBox3D *box) {
 // TODO: Maybe it would be useful to have a similar method for projective points pt because then we
 //       can use it for VPs and perhaps merge the case distinctions during z-order recomputation.
 int
-box3d_pt_lies_in_PL_sector (SPBox3D const *box, NR::Point const &pt, int id1, int id2, Box3D::Axis axis) {
+box3d_pt_lies_in_PL_sector (SPBox3D const *box, Geom::Point const &pt, int id1, int id2, Box3D::Axis axis) {
     Persp3D *persp = box3d_get_perspective(box);
 
     // the two corners
-    NR::Point c1(box3d_get_corner_screen(box, id1, false));
-    NR::Point c2(box3d_get_corner_screen(box, id2, false));
+    Geom::Point c1(box3d_get_corner_screen(box, id1, false));
+    Geom::Point c2(box3d_get_corner_screen(box, id2, false));
 
     int ret = 0;
     if (persp3d_VP_is_finite(persp, Box3D::toProj(axis))) {
-        NR::Point vp(persp3d_get_VP(persp, Box3D::toProj(axis)).affine());
-        NR::Point v1(c1 - vp);
-        NR::Point v2(c2 - vp);
-        NR::Point w(pt - vp);
+        Geom::Point vp(persp3d_get_VP(persp, Box3D::toProj(axis)).affine());
+        Geom::Point v1(c1 - vp);
+        Geom::Point v2(c2 - vp);
+        Geom::Point w(pt - vp);
         ret = static_cast<int>(Box3D::lies_in_sector(v1, v2, w));
     } else {
         Box3D::PerspectiveLine pl1(c1, Box3D::toProj(axis), persp);
@@ -1208,7 +1208,7 @@ box3d_pt_lies_in_PL_sector (SPBox3D const *box, NR::Point const &pt, int id1, in
         if (pl1.lie_on_same_side(pt, c2) && pl2.lie_on_same_side(pt, c1)) {
             // test whether pt lies "towards" or "away from" the VP
             Box3D::Line edge(c1,c2);
-            NR::Point c3(box3d_get_corner_screen(box, id1 ^ axis, false));
+            Geom::Point c3(box3d_get_corner_screen(box, id1 ^ axis, false));
             if (edge.lie_on_same_side(pt, c3)) {
                 ret = 1;
             } else {
@@ -1341,8 +1341,8 @@ box3d_switch_perspectives(SPBox3D *box, Persp3D *old_persp, Persp3D *new_persp,
         box->orig_corner7.normalize();
         double z0 = box->orig_corner0[Proj::Z];
         double z7 = box->orig_corner7[Proj::Z];
-        NR::Point corner0_screen = box3d_get_corner_screen(box, 0, false);
-        NR::Point corner7_screen = box3d_get_corner_screen(box, 7, false);
+        Geom::Point corner0_screen = box3d_get_corner_screen(box, 0, false);
+        Geom::Point corner7_screen = box3d_get_corner_screen(box, 7, false);
 
         box->orig_corner0 = new_persp->tmat.preimage(corner0_screen, z0, Proj::Z);
         box->orig_corner7 = new_persp->tmat.preimage(corner7_screen, z7, Proj::Z);

diff --git a/src/box3d.h b/src/box3d.h
index 95327567960affc690885061ee79b1fb3d1949f1..b6d962a3c924375ca6c6b3daa34df8c0e4dc53a7 100644 (file)
--- a/src/box3d.h
+++ b/src/box3d.h
@@ -54,17 +54,17 @@ GType box3d_get_type (void);
 
 void box3d_position_set (SPBox3D *box);
 Proj::Pt3 box3d_get_proj_corner (SPBox3D const *box, guint id);
-NR::Point box3d_get_corner_screen (SPBox3D const *box, guint id, bool item_coords = true);
+Geom::Point box3d_get_corner_screen (SPBox3D const *box, guint id, bool item_coords = true);
 Proj::Pt3 box3d_get_proj_center (SPBox3D *box);
-NR::Point box3d_get_center_screen (SPBox3D *box);
+Geom::Point box3d_get_center_screen (SPBox3D *box);
 
-void box3d_set_corner (SPBox3D *box, guint id, NR::Point const &new_pos, Box3D::Axis movement, bool constrained);
-void box3d_set_center (SPBox3D *box, NR::Point const &new_pos, NR::Point const &old_pos, Box3D::Axis movement, bool constrained);
-void box3d_corners_for_PLs (const SPBox3D * box, Proj::Axis axis, NR::Point &corner1, NR::Point &corner2, NR::Point &corner3, NR::Point &corner4);
+void box3d_set_corner (SPBox3D *box, guint id, Geom::Point const &new_pos, Box3D::Axis movement, bool constrained);
+void box3d_set_center (SPBox3D *box, Geom::Point const &new_pos, Geom::Point const &old_pos, Box3D::Axis movement, bool constrained);
+void box3d_corners_for_PLs (const SPBox3D * box, Proj::Axis axis, Geom::Point &corner1, Geom::Point &corner2, Geom::Point &corner3, Geom::Point &corner4);
 bool box3d_recompute_z_orders (SPBox3D *box);
 void box3d_set_z_orders (SPBox3D *box);
 
-int box3d_pt_lies_in_PL_sector (SPBox3D const *box, NR::Point const &pt, int id1, int id2, Box3D::Axis axis);
+int box3d_pt_lies_in_PL_sector (SPBox3D const *box, Geom::Point const &pt, int id1, int id2, Box3D::Axis axis);
 int box3d_VP_lies_in_PL_sector (SPBox3D const *box, Proj::Axis vpdir, int id1, int id2, Box3D::Axis axis);
 
 void box3d_relabel_corners(SPBox3D *box);

diff --git a/src/persp3d.cpp b/src/persp3d.cpp
index ec4244f6ba47b6eb5a679990c1d4c7f74ff08aee..71d12619bc5d60582611eb4e59f87f0ae738e036 100644 (file)
--- a/src/persp3d.cpp
+++ b/src/persp3d.cpp
@@ -288,7 +288,7 @@ persp3d_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML:
 }
 
 /* convenience wrapper around persp3d_get_finite_dir() and persp3d_get_infinite_dir() */
-NR::Point persp3d_get_PL_dir_from_pt (Persp3D *persp, NR::Point const &pt, Proj::Axis axis) {
+Geom::Point persp3d_get_PL_dir_from_pt (Persp3D *persp, Geom::Point const &pt, Proj::Axis axis) {
     if (persp3d_VP_is_finite(persp, axis)) {
         return persp3d_get_finite_dir(persp, pt, axis);
     } else {
@@ -296,20 +296,20 @@ NR::Point persp3d_get_PL_dir_from_pt (Persp3D *persp, NR::Point const &pt, Proj:
     }
 }
 
-NR::Point
-persp3d_get_finite_dir (Persp3D *persp, NR::Point const &pt, Proj::Axis axis) {
+Geom::Point
+persp3d_get_finite_dir (Persp3D *persp, Geom::Point const &pt, Proj::Axis axis) {
     Box3D::PerspectiveLine pl(pt, axis, persp);
     return pl.direction();
 }
 
-NR::Point
+Geom::Point
 persp3d_get_infinite_dir (Persp3D *persp, Proj::Axis axis) {
     Proj::Pt2 vp(persp3d_get_VP(persp, axis));
     if (vp[2] != 0.0) {
         g_print ("VP should be infinite but is (%f : %f : %f)\n", vp[0], vp[1], vp[2]);
-        g_return_val_if_fail(vp[2] != 0.0, NR::Point(0.0, 0.0));
+        g_return_val_if_fail(vp[2] != 0.0, Geom::Point(0.0, 0.0));
     }
-    return NR::Point(vp[0], vp[1]);
+    return Geom::Point(vp[0], vp[1]);
 }
 
 double
@@ -361,8 +361,8 @@ persp3d_rotate_VP (Persp3D *persp, Proj::Axis axis, double angle, bool alt_press
         return;
     }
     Proj::Pt2 v_dir_proj (persp->tmat.column(axis));
-    NR::Point v_dir (v_dir_proj[0], v_dir_proj[1]);
-    double a = NR::atan2 (v_dir) * 180/M_PI;
+    Geom::Point v_dir (v_dir_proj[0], v_dir_proj[1]);
+    double a = Geom::atan2 (v_dir) * 180/M_PI;
     a += alt_pressed ? 0.5 * ((angle > 0 ) - (angle < 0)) : angle; // the r.h.s. yields +/-0.5 or angle
     persp->tmat.set_infinite_direction (axis, a);
 
@@ -376,7 +376,7 @@ persp3d_update_with_point (Persp3D *persp, Proj::Axis const axis, Proj::Pt2 cons
 }
 
 void
-persp3d_apply_affine_transformation (Persp3D *persp, NR::Matrix const &xform) {
+persp3d_apply_affine_transformation (Persp3D *persp, Geom::Matrix const &xform) {
     persp->tmat *= xform;
     persp3d_update_box_reprs(persp);
     SP_OBJECT(persp)->updateRepr(SP_OBJECT_WRITE_EXT);

diff --git a/src/persp3d.h b/src/persp3d.h
index c0fabc0921f0abb079a0ef2dc2e4645a2036b7c1..79bec0232c5372465266a04e90924ade2e8e1481 100644 (file)
--- a/src/persp3d.h
+++ b/src/persp3d.h
@@ -56,9 +56,9 @@ inline Persp3D * persp3d_get_from_repr (Inkscape::XML::Node *repr) {
 inline Proj::Pt2 persp3d_get_VP (Persp3D *persp, Proj::Axis axis) {
     return persp->tmat.column(axis);
 }
-NR::Point persp3d_get_PL_dir_from_pt (Persp3D *persp, NR::Point const &pt, Proj::Axis axis); // convenience wrapper around the following two
-NR::Point persp3d_get_finite_dir (Persp3D *persp, NR::Point const &pt, Proj::Axis axis);
-NR::Point persp3d_get_infinite_dir (Persp3D *persp, Proj::Axis axis);
+Geom::Point persp3d_get_PL_dir_from_pt (Persp3D *persp, Geom::Point const &pt, Proj::Axis axis); // convenience wrapper around the following two
+Geom::Point persp3d_get_finite_dir (Persp3D *persp, Geom::Point const &pt, Proj::Axis axis);
+Geom::Point persp3d_get_infinite_dir (Persp3D *persp, Proj::Axis axis);
 double persp3d_get_infinite_angle (Persp3D *persp, Proj::Axis axis);
 bool persp3d_VP_is_finite (Persp3D *persp, Proj::Axis axis);
 void persp3d_toggle_VP (Persp3D *persp, Proj::Axis axis, bool set_undo = true);
@@ -66,7 +66,7 @@ void persp3d_toggle_VPs (std::list<Persp3D *>, Proj::Axis axis);
 void persp3d_set_VP_state (Persp3D *persp, Proj::Axis axis, Proj::VPState state);
 void persp3d_rotate_VP (Persp3D *persp, Proj::Axis axis, double angle, bool alt_pressed); // angle is in degrees
 void persp3d_update_with_point (Persp3D *persp, Proj::Axis const axis, Proj::Pt2 const &new_image);
-void persp3d_apply_affine_transformation (Persp3D *persp, NR::Matrix const &xform);
+void persp3d_apply_affine_transformation (Persp3D *persp, Geom::Matrix const &xform);
 gchar * persp3d_pt_to_str (Persp3D *persp, Proj::Axis const axis);
 
 void persp3d_add_box (Persp3D *persp, SPBox3D *box);

diff --git a/src/perspective-line.cpp b/src/perspective-line.cpp
index 051a1d94acb6d2cbcf7d53f24138560aac27aa44..3e7d96fdd187fd28f6828b279de8b319472957e5 100644 (file)
--- a/src/perspective-line.cpp
+++ b/src/perspective-line.cpp
@@ -16,14 +16,14 @@
 
 namespace Box3D {
 
-PerspectiveLine::PerspectiveLine (NR::Point const &pt, Proj::Axis const axis, Persp3D *persp) :
+PerspectiveLine::PerspectiveLine (Geom::Point const &pt, Proj::Axis const axis, Persp3D *persp) :
         Line (pt, persp3d_get_VP(persp, axis).affine(), true)
 {
     g_assert (persp != NULL);
 
     if (!persp3d_get_VP(persp, axis).is_finite()) {
         Proj::Pt2 vp(persp3d_get_VP(persp, axis));
-        this->set_direction(NR::Point(vp[Proj::X], vp[Proj::Y]));
+        this->set_direction(Geom::Point(vp[Proj::X], vp[Proj::Y]));
     }
     this->vp_dir = axis;
     this->persp  = persp;

diff --git a/src/perspective-line.h b/src/perspective-line.h
index e0235aafc72f830f31512b1f3c86437879e33ea3..57abaae9c2148f3147cb065b2d18ba7e5c770ad2 100644 (file)
--- a/src/perspective-line.h
+++ b/src/perspective-line.h
@@ -27,7 +27,7 @@ public:
      * PL runs through it; otherwise it has the direction specified by the v_dir vector
      * of the VP.
      */
-    PerspectiveLine (NR::Point const &pt, Proj::Axis const axis, Persp3D *persp);
+    PerspectiveLine (Geom::Point const &pt, Proj::Axis const axis, Persp3D *persp);
 
 private:
     Proj::Axis vp_dir; // direction of the associated VP

diff --git a/src/proj_pt.cpp b/src/proj_pt.cpp
index d7906a4e243202cf973ee95136ff03f54c417a40..9294046ab43bc46fc8ed93609adc029613fcd9ea 100644 (file)
--- a/src/proj_pt.cpp
+++ b/src/proj_pt.cpp
@@ -45,12 +45,12 @@ Pt2::normalize() {
     pt[2] = 1.0;
 }
 
-NR::Point
+Geom::Point
 Pt2::affine() {
   if (fabs(pt[2]) < epsilon) {
-    return NR::Point (NR_HUGE, NR_HUGE);
+    return Geom::Point (NR_HUGE, NR_HUGE);
   }
-  return NR::Point (pt[0]/pt[2], pt[1]/pt[2]);
+  return Geom::Point (pt[0]/pt[2], pt[1]/pt[2]);
 }
 
 gchar *

diff --git a/src/proj_pt.h b/src/proj_pt.h
index b14dea50e3b73fcfeab0b0168ee29abaa7508bd1..844cbb2c42732fd9e86f6d7e454728764c0ced11 100644 (file)
--- a/src/proj_pt.h
+++ b/src/proj_pt.h
@@ -13,7 +13,6 @@
  */
 
 #include <2geom/point.h>
-#include "libnr/nr-point.h"
 #include "libnr/nr-values.h"
 #include <gtk/gtk.h>
 
@@ -26,7 +25,6 @@ class Pt2 {
 public:
     Pt2 () { pt[0] = 0; pt[1] = 0; pt[2] = 1.0; } // we default to (0 : 0 : 1)
     Pt2 (double x, double y, double w) { pt[0] = x; pt[1] = y; pt[2] = w; }
-    Pt2 (NR::Point const &point) { pt[0] = point[NR::X]; pt[1] = point[NR::Y]; pt[2] = 1; }
     Pt2 (Geom::Point const &point) { pt[0] = point[Geom::X]; pt[1] = point[Geom::Y]; pt[2] = 1; }
     Pt2 (const gchar *coord_str);
 
@@ -82,7 +80,7 @@ public:
     }
 
     void normalize();
-    NR::Point affine();
+    Geom::Point affine();
     inline bool is_finite() { return pt[2] != 0; } // FIXME: Should we allow for some tolerance?
     gchar *coord_string();
     inline void print(gchar const *s) const { g_print ("%s(%8.2f : %8.2f : %8.2f)\n", s, pt[0], pt[1], pt[2]); }

diff --git a/src/transf_mat_3x4.cpp b/src/transf_mat_3x4.cpp
index ec03b0de6314bf94e239d8718c5e1b3eef83d77a..b7cd278d4febfdf28b665b89629655843bcdb180 100644 (file)
--- a/src/transf_mat_3x4.cpp
+++ b/src/transf_mat_3x4.cpp
@@ -13,9 +13,9 @@
 
 #include "transf_mat_3x4.h"
 #include <gtk/gtk.h>
+#include <2geom/matrix.h>
 #include "svg/stringstream.h"
 #include "syseq.h"
-#include "libnr/nr-matrix.h"
 #include "document.h"
 #include "inkscape.h"
 
@@ -61,11 +61,11 @@ TransfMat3x4::image (Pt3 const &point) {
 }
 
 Pt3
-TransfMat3x4::preimage (NR::Point const &pt, double coord, Proj::Axis axis) {
+TransfMat3x4::preimage (Geom::Point const &pt, double coord, Proj::Axis axis) {
     double x[4];
     double v[3];
-    v[0] = pt[NR::X];
-    v[1] = pt[NR::Y];
+    v[0] = pt[Geom::X];
+    v[1] = pt[Geom::Y];
     v[2] = 1.0;
     int index = (int) axis;
 
@@ -93,10 +93,10 @@ void
 TransfMat3x4::toggle_finite (Proj::Axis axis) {
     g_return_if_fail (axis != Proj::W);
     if (has_finite_image(axis)) {
-        NR::Point dir (column(axis).affine());
-        NR::Point origin (column(Proj::W).affine());
+        Geom::Point dir (column(axis).affine());
+        Geom::Point origin (column(Proj::W).affine());
         dir -= origin;
-        set_column (axis, Proj::Pt2(dir[NR::X], dir[NR::Y], 0));
+        set_column (axis, Proj::Pt2(dir[Geom::X], dir[Geom::Y], 0));
     } else {
         Proj::Pt2 dir (column(axis));
         Proj::Pt2 origin (column(Proj::W).affine());
@@ -131,7 +131,7 @@ TransfMat3x4::operator==(const TransfMat3x4 &rhs) const
 
 /* multiply a projective matrix by an affine matrix */
 TransfMat3x4
-TransfMat3x4::operator*(NR::Matrix const &A) const {
+TransfMat3x4::operator*(Geom::Matrix const &A) const {
     TransfMat3x4 ret;
 
     // Is it safe to always use the currently active document?
@@ -141,7 +141,7 @@ TransfMat3x4::operator*(NR::Matrix const &A) const {
      * Note: The strange multiplication involving the document height is due to the buggy
      *       intertwining of SVG and document coordinates. Essentially, what we do is first
      *       convert from "real-world" to SVG coordinates, then apply the transformation A
-     *       (by multiplying with the NR::Matrix) and then convert back from SVG to real-world
+     *       (by multiplying with the Geom::Matrix) and then convert back from SVG to real-world
      *       coordinates. Maybe there is even a more Inkscape-ish way to achieve this?
      *       Once Inkscape has gotton rid of the two different coordiate systems, we can change
      *       this function to an ordinary matrix multiplication.
@@ -160,7 +160,7 @@ TransfMat3x4::operator*(NR::Matrix const &A) const {
 // FIXME: Shouldn't rather operator* call operator*= for efficiency? (Because in operator*=
 //        there is in principle no need to create a temporary object, which happens in the assignment)
 TransfMat3x4 &
-TransfMat3x4::operator*=(NR::Matrix const &A) {
+TransfMat3x4::operator*=(Geom::Matrix const &A) {
     *this = *this * A;
     return *this;
 }

diff --git a/src/transf_mat_3x4.h b/src/transf_mat_3x4.h
index 58d332cb93301b1bdc923099f4f5e140e7b3c122..53c9ffa8124ce9f5b168081903c296fc3aa209bf 100644 (file)
--- a/src/transf_mat_3x4.h
+++ b/src/transf_mat_3x4.h
@@ -12,7 +12,6 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include "libnr/nr-point-fns.h"
 #include "proj_pt.h"
 #include "axis-manip.h"
 
@@ -25,22 +24,22 @@ public:
     TransfMat3x4(TransfMat3x4 const &rhs);
     Pt2 column (Proj::Axis axis) const;
     Pt2 image (Pt3 const &point);
-    Pt3 preimage (NR::Point const &pt, double coord = 0, Axis = Z);
+    Pt3 preimage (Geom::Point const &pt, double coord = 0, Axis = Z);
     void set_image_pt (Proj::Axis axis, Proj::Pt2 const &pt);
     void toggle_finite (Proj::Axis axis);
     double get_infinite_angle (Proj::Axis axis) {
         if (has_finite_image(axis)) {
-            return NR_HUGE;
+            return 1e18; //this used to be NR_HUGE before 2geom conversion
         }
         Pt2 vp(column(axis));
-        return NR::atan2(NR::Point(vp[0], vp[1])) * 180.0/M_PI;
+        return Geom::atan2(Geom::Point(vp[0], vp[1])) * 180.0/M_PI;
     }
     void set_infinite_direction (Proj::Axis axis, double angle) { // angle is in degrees
         g_return_if_fail(tmat[2][axis] == 0); // don't set directions for finite VPs
 
         double a = angle * M_PI/180;
-        NR::Point pt(tmat[0][axis], tmat[1][axis]);
-        double rad = NR::L2(pt);
+        Geom::Point pt(tmat[0][axis], tmat[1][axis]);
+        double rad = Geom::L2(pt);
         set_image_pt(axis, Proj::Pt2(cos (a) * rad, sin (a) * rad, 0.0));
     }
     inline bool has_finite_image (Proj::Axis axis) { return (tmat[2][axis] != 0.0); }
@@ -48,8 +47,8 @@ public:
     gchar * pt_to_str (Proj::Axis axis);
 
     bool operator==(const TransfMat3x4 &rhs) const;
-    TransfMat3x4 operator*(NR::Matrix const &A) const;
-    TransfMat3x4 &operator*=(NR::Matrix const &A);
+    TransfMat3x4 operator*(Geom::Matrix const &A) const;
+    TransfMat3x4 &operator*=(Geom::Matrix const &A);
 
     void print() const;
 

diff --git a/src/vanishing-point.cpp b/src/vanishing-point.cpp
index ac123792db6c595975fb53bca033f16ab0170658..14bf8d1619ba2f85c5e1b9e82e1e3e7a865b957a 100644 (file)
--- a/src/vanishing-point.cpp
+++ b/src/vanishing-point.cpp
@@ -77,12 +77,12 @@ have_VPs_of_same_perspective (VPDragger *dr1, VPDragger *dr2)
 }
 
 static void
-vp_knot_moved_handler (SPKnot */*knot*/, NR::Point const *ppointer, guint state, gpointer data)
+vp_knot_moved_handler (SPKnot */*knot*/, Geom::Point const *ppointer, guint state, gpointer data)
 {
     VPDragger *dragger = (VPDragger *) data;
     VPDrag *drag = dragger->parent;
 
-    NR::Point p = *ppointer;
+    Geom::Point p = *ppointer;
 
     // FIXME: take from prefs
     double snap_dist = SNAP_DIST / inkscape_active_desktop()->current_zoom();
@@ -248,7 +248,7 @@ VanishingPoint::selectedBoxes(Inkscape::Selection *sel) {
     return sel_boxes;
 }
 
-VPDragger::VPDragger(VPDrag *parent, NR::Point p, VanishingPoint &vp)
+VPDragger::VPDragger(VPDrag *parent, Geom::Point p, VanishingPoint &vp)
 {
     this->parent = parent;
 
@@ -440,7 +440,7 @@ VPDragger::updateBoxDisplays ()
 }
 
 void
-VPDragger::updateVPs (NR::Point const &pt)
+VPDragger::updateVPs (Geom::Point const &pt)
 {
     for (std::list<VanishingPoint>::iterator i = this->vps.begin(); i != this->vps.end(); ++i) {
         (*i).set_pos (pt);
@@ -657,14 +657,14 @@ VPDrag::drawLinesForFace (const SPBox3D *box, Proj::Axis axis) //, guint corner1
         default: g_assert_not_reached();
     }
 
-    NR::Point corner1, corner2, corner3, corner4;
+    Geom::Point corner1, corner2, corner3, corner4;
     box3d_corners_for_PLs (box, axis, corner1, corner2, corner3, corner4);
 
     g_return_if_fail (box3d_get_perspective(box));
     Proj::Pt2 vp = persp3d_get_VP (box3d_get_perspective(box), axis);
     if (vp.is_finite()) {
         // draw perspective lines for finite VPs
-        NR::Point pt = vp.affine();
+        Geom::Point pt = vp.affine();
         if (this->front_or_rear_lines & 0x1) {
             // draw 'front' perspective lines
             this->addLine (corner1, pt, color);
@@ -677,7 +677,7 @@ VPDrag::drawLinesForFace (const SPBox3D *box, Proj::Axis axis) //, guint corner1
         }
     } else {
         // draw perspective lines for infinite VPs
-        boost::optional<NR::Point> pt1, pt2, pt3, pt4;
+        boost::optional<Geom::Point> pt1, pt2, pt3, pt4;
         Persp3D *persp = box3d_get_perspective(box);
         SPDesktop *desktop = inkscape_active_desktop (); // FIXME: Store the desktop in VPDrag
         Box3D::PerspectiveLine pl (corner1, axis, persp);
@@ -721,7 +721,7 @@ VPDrag::addDragger (VanishingPoint &vp)
         // don't create draggers for infinite vanishing points
         return;
     }
-    NR::Point p = vp.get_pos();
+    Geom::Point p = vp.get_pos();
 
     for (GList *i = this->draggers; i != NULL; i = i->next) {
         VPDragger *dragger = (VPDragger *) i->data;
@@ -755,7 +755,7 @@ VPDrag::swap_perspectives_of_VPs(Persp3D *persp2, Persp3D *persp1)
 Create a line from p1 to p2 and add it to the lines list
  */
 void
-VPDrag::addLine (NR::Point p1, NR::Point p2, guint32 rgba)
+VPDrag::addLine (Geom::Point p1, Geom::Point p2, guint32 rgba)
 {
     SPCanvasItem *line = sp_canvas_item_new(sp_desktop_controls(inkscape_active_desktop()), SP_TYPE_CTRLLINE, NULL);
     sp_ctrlline_set_coords(SP_CTRLLINE(line), p1, p2);

diff --git a/src/vanishing-point.h b/src/vanishing-point.h
index aef5f6f5c4370d874c82dec2ffad2feb8fe95eba..9fcb6bb46d6440a0e35bf8b67311add2df68d78f 100644 (file)
--- a/src/vanishing-point.h
+++ b/src/vanishing-point.h
@@ -13,7 +13,7 @@
 #define SEEN_VANISHING_POINT_H
 
 #include <set>
-#include "libnr/nr-point.h"
+#include <2geom/point.h>
 #include "knot.h"
 #include "selection.h"
 #include "axis-manip.h"
@@ -66,8 +66,8 @@ public:
         g_return_val_if_fail (_persp, false);
         return persp3d_get_VP (_persp, _axis).is_finite();
     }
-    inline NR::Point get_pos() const {
-        g_return_val_if_fail (_persp, NR::Point (NR_HUGE, NR_HUGE));
+    inline Geom::Point get_pos() const {
+        g_return_val_if_fail (_persp, Geom::Point (NR_HUGE, NR_HUGE));
         return persp3d_get_VP (_persp,_axis).affine();
     }
     inline Persp3D * get_perspective() const {
@@ -122,16 +122,16 @@ struct less_ptr : public std::binary_function<VanishingPoint *, VanishingPoint *
 
 struct VPDragger {
 public:
-    VPDragger(VPDrag *parent, NR::Point p, VanishingPoint &vp);
+    VPDragger(VPDrag *parent, Geom::Point p, VanishingPoint &vp);
     ~VPDragger();
 
     VPDrag *parent;
     SPKnot *knot;
 
     // position of the knot, desktop coords
-    NR::Point point;
+    Geom::Point point;
     // position of the knot before it began to drag; updated when released
-    NR::Point point_original;
+    Geom::Point point_original;
 
     bool dragging_started;
 
@@ -150,7 +150,7 @@ public:
     void mergePerspectives(); // remove duplicate perspectives
 
     void updateBoxDisplays();
-    void updateVPs(NR::Point const &pt);
+    void updateVPs(Geom::Point const &pt);
     void updateZOrders();
 
     void printVPs();
@@ -199,7 +199,7 @@ public:
 private:
     //void deselect_all();
 
-    void addLine (NR::Point p1, NR::Point p2, guint32 rgba);
+    void addLine (Geom::Point p1, Geom::Point p2, guint32 rgba);
 
     Inkscape::Selection *selection;
     sigc::connection sel_changed_connection;