BRL-CAD

Revision: 52781
          http://brlcad.svn.sourceforge.net/brlcad/?rev=52781&view=rev
Author:   n_reed
Date:     2012-10-04 16:28:37 +0000 (Thu, 04 Oct 2012)
Log Message:
-----------
tweak logic for determining number of curve samples in adaptive plot routines

Modified Paths:
--------------
    brlcad/trunk/src/librt/librt_private.h
    brlcad/trunk/src/librt/primitives/ell/ell.c
    brlcad/trunk/src/librt/primitives/epa/epa.c
    brlcad/trunk/src/librt/primitives/primitive_util.c
    brlcad/trunk/src/librt/primitives/tgc/tgc.c

Modified: brlcad/trunk/src/librt/librt_private.h
===================================================================
--- brlcad/trunk/src/librt/librt_private.h	2012-10-04 16:23:32 UTC (rev 52780)
+++ brlcad/trunk/src/librt/librt_private.h	2012-10-04 16:28:37 UTC (rev 52781)
@@ -91,8 +91,14 @@
 extern void rt_plot_cell(const union cutter *cutp, struct rt_shootray_status *ssp, struct bu_list *waiting_segs_hd, struct rt_i *rtip);
 
 
-extern fastf_t primitive_get_absolute_tolerance(const struct rt_tess_tol *ttol, fastf_t rel_to_abs);
+extern fastf_t primitive_get_absolute_tolerance(
+	const struct rt_tess_tol *ttol,
+	fastf_t rel_to_abs);
 
+extern fastf_t primitive_diagonal_samples(
+	struct rt_db_internal *ip,
+	const struct rt_view_info *info);
+
 __END_DECLS
 
 /*

Modified: brlcad/trunk/src/librt/primitives/ell/ell.c
===================================================================
--- brlcad/trunk/src/librt/primitives/ell/ell.c	2012-10-04 16:23:32 UTC (rev 52780)
+++ brlcad/trunk/src/librt/primitives/ell/ell.c	2012-10-04 16:28:37 UTC (rev 52781)
@@ -787,26 +787,6 @@
     }
 }
 
-static fastf_t
-curve_samples(struct rt_db_internal *ip, const struct rt_view_info *info)
-{
-    point_t bbox_min, bbox_max;
-    fastf_t primitive_diagonal_mm, samples_per_mm;
-    fastf_t diagonal_samples;
-
-    ip->idb_meth->ft_bbox(ip, &bbox_min, &bbox_max, info->tol);
-    primitive_diagonal_mm = DIST_PT_PT(bbox_min, bbox_max);
-
-    samples_per_mm = sqrt(info->view_samples) / info->view_size;
-    diagonal_samples = samples_per_mm * primitive_diagonal_mm;
-
-#if 0
-    bu_log("%.2f diagonal_samples = (%.2f view_samples / (%.2f * %.2f info->view_size)) * %.2f diagonal_mm\n", diagonal_samples, info->view_samples, info->view_size, info->view_size, primitive_diagonal_mm);
-#endif
-
-    return diagonal_samples;
-}
-
 int
 rt_ell_adaptive_plot(struct rt_db_internal *ip, const struct rt_view_info *info)
 {
@@ -819,7 +799,7 @@
     eip = (struct rt_ell_internal *)ip->idb_ptr;
     RT_ELL_CK_MAGIC(eip);
 
-    samples = curve_samples(ip, info);
+    samples = primitive_diagonal_samples(ip, info);
 
     config.vhead = info->vhead;
     VMOVE(config.ell_center, eip->v);
@@ -843,10 +823,6 @@
 	config.num_cross_sections = 5;
     }
 
-#if 0
-    bu_log("%d points per cross section (%.2f samples)\n", config.points_per_section, samples);
-#endif
-
     VMOVE(config.ell_travel_vector, eip->a);
     VMOVE(config.ell_axis_vector_a, eip->b);
     VMOVE(config.ell_axis_vector_b, eip->c);

Modified: brlcad/trunk/src/librt/primitives/epa/epa.c
===================================================================
--- brlcad/trunk/src/librt/primitives/epa/epa.c	2012-10-04 16:23:32 UTC (rev 52780)
+++ brlcad/trunk/src/librt/primitives/epa/epa.c	2012-10-04 16:28:37 UTC (rev 52781)
@@ -875,9 +875,14 @@
     struct rt_epa_internal *epa;
     struct rt_pt_node *pts_r1, *pts_r2, *node1, *node2;
 
-    num_curve_points = 4;
-    num_ellipse_points = 16;
+    num_curve_points = sqrt(primitive_diagonal_samples(ip, info)) / 4.0;
 
+    if (num_curve_points < 3) {
+	num_curve_points = 3;
+    }
+
+    num_ellipse_points = 4 * num_curve_points;
+
     BU_CK_LIST_HEAD(info->vhead);
     RT_CK_DB_INTERNAL(ip);
     epa = (struct rt_epa_internal *)ip->idb_ptr;

Modified: brlcad/trunk/src/librt/primitives/primitive_util.c
===================================================================
--- brlcad/trunk/src/librt/primitives/primitive_util.c	2012-10-04 16:23:32 UTC (rev 52780)
+++ brlcad/trunk/src/librt/primitives/primitive_util.c	2012-10-04 16:28:37 UTC (rev 52781)
@@ -37,7 +37,9 @@
  */
 #define DEFAULT_REL_TOL .1
 fastf_t
-primitive_get_absolute_tolerance(const struct rt_tess_tol *ttol, fastf_t rel_to_abs)
+primitive_get_absolute_tolerance(
+	const struct rt_tess_tol *ttol,
+	fastf_t rel_to_abs)
 {
     fastf_t tol, rel_tol, abs_tol;
     int rel_tol_is_valid;
@@ -61,3 +63,32 @@
 
     return tol;
 }
+
+/**
+ * Gives a rough estimate of the maximum number of times a primitive's bounding
+ * box diagonal will be sampled based on the sample density of the view.
+ *
+ * Practically, it is an estimate of the maximum number of pixels that would be
+ * used if the diagonal line were drawn in the current view window.
+ *
+ * It is currently used in adaptive plot routines to help choose how many
+ * sample points should be used for plotted curves.
+ */
+fastf_t
+primitive_diagonal_samples(
+	struct rt_db_internal *ip,
+	const struct rt_view_info *info)
+{
+    point_t bbox_min, bbox_max;
+    fastf_t primitive_diagonal_mm, samples_per_mm;
+    fastf_t diagonal_samples;
+
+    ip->idb_meth->ft_bbox(ip, &bbox_min, &bbox_max, info->tol);
+    primitive_diagonal_mm = DIST_PT_PT(bbox_min, bbox_max);
+
+    samples_per_mm = sqrt(info->view_samples) / info->view_size;
+    diagonal_samples = samples_per_mm * primitive_diagonal_mm;
+
+    return diagonal_samples;
+}
+

Modified: brlcad/trunk/src/librt/primitives/tgc/tgc.c
===================================================================
--- brlcad/trunk/src/librt/primitives/tgc/tgc.c	2012-10-04 16:23:32 UTC (rev 52780)
+++ brlcad/trunk/src/librt/primitives/tgc/tgc.c	2012-10-04 16:28:37 UTC (rev 52781)
@@ -1803,26 +1803,6 @@
     ip->idb_ptr = GENPTR_NULL;
 }
 
-static fastf_t
-curve_samples(struct rt_db_internal *ip, const struct rt_view_info *info)
-{
-    point_t bbox_min, bbox_max;
-    fastf_t primitive_diagonal_mm, samples_per_mm;
-    fastf_t diagonal_samples;
-
-    ip->idb_meth->ft_bbox(ip, &bbox_min, &bbox_max, info->tol);
-    primitive_diagonal_mm = DIST_PT_PT(bbox_min, bbox_max);
-
-    samples_per_mm = sqrt(info->view_samples) / info->view_size;
-    diagonal_samples = samples_per_mm * primitive_diagonal_mm;
-
-#if 0
-    bu_log("%.2f diagonal_samples = (%.2f view_samples / (%.2f * %.2f info->view_size)) * %.2f diagonal_mm\n", diagonal_samples, info->view_samples, info->view_size, info->view_size, primitive_diagonal_mm);
-#endif
-
-    return diagonal_samples;
-}
-
 struct ellipse {
     point_t center;
     vect_t axis_a;
@@ -1892,7 +1872,7 @@
     tip = (struct rt_tgc_internal *)ip->idb_ptr;
     RT_TGC_CK_MAGIC(tip);
 
-    samples = sqrt(curve_samples(ip, info));
+    samples = sqrt(primitive_diagonal_samples(ip, info));
     if (samples < 6.0) {
 	samples = 6.0;
     }
@@ -1907,9 +1887,9 @@
     VMOVE(ellipse2.axis_b, tip->d);
     draw_ellipse(info->vhead, ellipse2, samples);
 
-    samples /= 4.0;
-    if (samples < 4.0) {
-	samples = 4.0;
+    samples /= 2.0;
+    if (samples < 3.0) {
+	samples = 3.0;
     }
 
     draw_lines_between_ellipses(info->vhead, ellipse1, ellipse2, samples);

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[52940] brlcad/trunk/src/librt From: <starseeker@us...> - 2012-10-10 14:23 Revision: 52940 http://brlcad.svn.sourceforge.net/brlcad/?rev=52940&view=rev Author: starseeker Date: 2012-10-10 14:23:26 +0000 (Wed, 10 Oct 2012) Log Message: ----------- Try implementing root-3 subdivision based on Leif Kobbelt's paper. Does not (unfortunately) interpolate the original points the way the modified butterfly scheme does, but butterfly seems to run the risk of introducing kinks. Just experimenting at this point, not hooked in to anything. Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt Added Paths: ----------- brlcad/trunk/src/librt/test_subdivision.cpp Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2012-10-10 14:14:28 UTC (rev 52939) +++ brlcad/trunk/src/librt/CMakeLists.txt 2012-10-10 14:23:26 UTC (rev 52940) @@ -252,6 +252,7 @@ namegen.c test_nurbsfit.cpp test_botpatches.cpp + test_subdivision.cpp prcomb.c primitives/bot/btg.h primitives/bot/g_bot_include.c Added: brlcad/trunk/src/librt/test_subdivision.cpp =================================================================== --- brlcad/trunk/src/librt/test_subdivision.cpp (rev 0) +++ brlcad/trunk/src/librt/test_subdivision.cpp 2012-10-10 14:23:26 UTC (rev 52940) @@ -0,0 +1,261 @@ +#include "common.h" + +#include <map> +#include <set> +#include <queue> +#include <list> +#include <iostream> +#include <fstream> + +#include "vmath.h" +#include "raytrace.h" +#include "wdb.h" +#include "plot3.h" +#include "opennurbs.h" + +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + +void plot_face(ON_3dPoint *pt1, ON_3dPoint *pt2, ON_3dPoint *pt3, int r, int g, int b, FILE *c_plot) +{ + point_t p1, p2, p3; + VSET(p1, pt1->x, pt1->y, pt1->z); + VSET(p2, pt2->x, pt2->y, pt2->z); + VSET(p3, pt3->x, pt3->y, pt3->z); + pl_color(c_plot, r, g, b); + pdv_3move(c_plot, p1); + pdv_3cont(c_plot, p2); + pdv_3move(c_plot, p1); + pdv_3cont(c_plot, p3); + pdv_3move(c_plot, p2); + pdv_3cont(c_plot, p3); +} + +struct Mesh_Info { + ON_3dPointArray points_p0; + ON_3dPointArray points_q; + std::map<size_t, size_t> iteration_of_insert; + std::map<size_t, std::vector<size_t> > face_pts; + std::map<size_t, size_t> index_in_next; + std::map<size_t, size_t> point_valence; + std::multimap<size_t, size_t> point_neighbors; + std::map<std::pair<size_t, size_t>, std::set<size_t> > edges_to_faces; + size_t iteration_cnt; +}; + +fastf_t alpha_n(size_t n) { + return (4 - 2 * cos(2*M_PI/n))/9; +} + +fastf_t beta_n_m(size_t n, size_t m) { + return (3 * alpha_n(n) - 3 * alpha_n(n) * pow((2/3 - alpha_n(n)), m))/(1+3*alpha_n(n)); +} + +void point_subdiv(size_t m, size_t p, struct Mesh_Info *mesh, ON_3dPointArray *p_a) { + size_t n = mesh->point_valence[p]; + std::multimap<size_t, size_t>::iterator p_it; + std::pair<std::multimap<size_t, size_t>::iterator, std::multimap<size_t, size_t>::iterator> range; + range = mesh->point_neighbors.equal_range(p); + ON_3dPoint psum = ON_3dPoint(0,0,0); + for(p_it = range.first; p_it != range.second; p_it++) { + psum = psum + *mesh->points_p0.At((*p_it).second); + } + fastf_t beta = beta_n_m(n, m); + ON_3dPoint subdiv_pt = (1 - beta) * *mesh->points_p0.At(p) + beta * 1/n * psum; + p_a->Append(subdiv_pt); +} + +// Make an edge using consistent vertex ordering +std::pair<size_t, size_t> mk_edge(size_t pt_A, size_t pt_B) +{ + if (pt_A <= pt_B) { + return std::make_pair(pt_A, pt_B); + } else { + return std::make_pair(pt_B, pt_A); + } +} + +void mesh_add_face(size_t pt1, size_t pt2, size_t pt3, size_t face_cnt, struct Mesh_Info *mesh) { + mesh->face_pts[face_cnt].push_back(pt1); + mesh->face_pts[face_cnt].push_back(pt2); + mesh->face_pts[face_cnt].push_back(pt3); + mesh->edges_to_faces[mk_edge(pt1, pt2)].insert(face_cnt); + mesh->edges_to_faces[mk_edge(pt2, pt3)].insert(face_cnt); + mesh->edges_to_faces[mk_edge(pt3, pt1)].insert(face_cnt); + mesh->point_neighbors.insert(std::pair<size_t, size_t>(pt1,pt2)); + mesh->point_neighbors.insert(std::pair<size_t, size_t>(pt2,pt3)); + mesh->point_neighbors.insert(std::pair<size_t, size_t>(pt3,pt1)); + mesh->point_valence[pt1] += 1; + mesh->point_valence[pt2] += 1; + mesh->point_valence[pt3] += 1; +} + +void mesh_info_init(struct rt_bot_internal *bot, struct Mesh_Info *mesh) +{ + for (size_t i = 0; i < bot->num_vertices; ++i) { + mesh->points_p0.Append(ON_3dPoint(&bot->vertices[i*3])); + mesh->iteration_of_insert[i] = 0; + } + for (size_t i = 0; i < bot->num_faces; ++i) { + mesh_add_face(bot->faces[i*3+0], bot->faces[i*3+1], bot->faces[i*3+2], i, mesh); + } + mesh->iteration_cnt = 0; +} + +// Find all edges in mesh +void get_all_edges(struct Mesh_Info *mesh, std::set<std::pair<size_t, size_t> > *edges) { + std::map<size_t, std::vector<size_t> >::iterator f_it; + std::vector<size_t>::iterator l_it; + for(f_it = mesh->face_pts.begin(); f_it != mesh->face_pts.end(); f_it++) { + l_it = (*f_it).second.begin(); + edges->insert(mk_edge((*l_it), (*(l_it+1)))); + edges->insert(mk_edge((*(l_it+1)), (*(l_it+2)))); + edges->insert(mk_edge((*(l_it+2)), (*l_it))); + } +} + +void find_q_pts(struct Mesh_Info *mesh) { + std::map<size_t, std::vector<size_t> >::iterator f_it; + std::vector<size_t>::iterator l_it; + for(f_it = mesh->face_pts.begin(); f_it != mesh->face_pts.end(); f_it++) { + ON_3dPoint p1, p2, p3; + l_it = (*f_it).second.begin(); + p1 = *mesh->points_p0.At((*l_it)); + p2 = *mesh->points_p0.At((*(l_it+1))); + p3 = *mesh->points_p0.At((*(l_it+2))); + ON_3dPoint q((p1.x + p2.x + p3.x)/3, (p1.y + p2.y + p3.y)/3, (p1.z + p2.z + p3.z)/3); + mesh->points_q.Append(q); + } +} + +struct Mesh_Info * iterate(struct rt_bot_internal *bot, struct Mesh_Info *prev_mesh, FILE* plot_file) { + std::map<size_t, std::vector<size_t> >::iterator f_it; + std::vector<size_t>::iterator l_it; + int r = int(256*drand48() + 1.0); + int g = int(256*drand48() + 1.0); + int b = int(256*drand48() + 1.0); + + struct Mesh_Info *starting_mesh; + if (!prev_mesh) { + starting_mesh = new Mesh_Info; + mesh_info_init(bot, starting_mesh); + } else { + starting_mesh = prev_mesh; + } + struct Mesh_Info *mesh = new Mesh_Info; + + mesh->iteration_cnt = starting_mesh->iteration_cnt + 1; + + find_q_pts(starting_mesh); + + // Relax old points here + for(size_t pcnt = 0; pcnt < (size_t)starting_mesh->points_p0.Count(); pcnt++) { + point_subdiv(mesh->iteration_cnt, pcnt, starting_mesh, &(mesh->points_p0)); + mesh->iteration_of_insert[pcnt] = starting_mesh->iteration_of_insert[pcnt]; + } + + for(f_it = starting_mesh->face_pts.begin(); f_it != starting_mesh->face_pts.end(); f_it++) { + mesh->points_p0.Append(starting_mesh->points_q[(*f_it).first]); + ON_3dPoint added = *mesh->points_p0.At(mesh->points_p0.Count() - 1); + mesh->iteration_of_insert[mesh->points_p0.Count()-1] = mesh->iteration_cnt; + starting_mesh->index_in_next[(*f_it).first] = mesh->points_p0.Count()-1; + } + // Use the old faces to guide the insertion of the new. + std::set<std::pair<size_t, size_t> > old_edges; + std::set<std::pair<size_t, size_t> >::iterator e_it; + get_all_edges(starting_mesh, &old_edges); + size_t face_cnt = 0; + for(f_it = starting_mesh->face_pts.begin(); f_it != starting_mesh->face_pts.end(); f_it++) { + std::set<std::pair<size_t, size_t> > face_old_edges; + size_t q0 = starting_mesh->index_in_next[(*f_it).first]; + l_it = (*f_it).second.begin(); + face_old_edges.insert(std::make_pair((*l_it), (*(l_it+1)))); + face_old_edges.insert(std::make_pair((*(l_it+1)), (*(l_it+2)))); + face_old_edges.insert(std::make_pair((*(l_it+2)), (*l_it))); + for(e_it = face_old_edges.begin(); e_it != face_old_edges.end(); e_it++) { + std::pair<size_t, size_t> edge = mk_edge((*e_it).first, (*e_it).second); + if (old_edges.find((edge)) != old_edges.end()) { + std::set<size_t> curr_faces = starting_mesh->edges_to_faces[edge]; + curr_faces.erase((*f_it).first); + size_t q1 = starting_mesh->index_in_next[*curr_faces.begin()]; + mesh_add_face((*e_it).first, q1, q0, face_cnt, mesh); + face_cnt++; + mesh_add_face((*e_it).second, q0, q1, face_cnt, mesh); + face_cnt++; + old_edges.erase(edge); + } + } + } + for(f_it = mesh->face_pts.begin(); f_it != mesh->face_pts.end(); f_it++) { + l_it = (*f_it).second.begin(); + plot_face(&mesh->points_p0[(*l_it)], &mesh->points_p0[(*(l_it+1))], &mesh->points_p0[(*(l_it+2))], r, g ,b, plot_file); + } + delete starting_mesh; + return mesh; +} + +int main(int argc, char *argv[]) +{ + struct db_i *dbip; + struct directory *dp; + struct rt_db_internal intern; + struct rt_bot_internal *bot_ip = NULL; + struct rt_wdb *wdbp; + struct bu_vls name; + struct bu_vls bname; + struct Mesh_Info *prev_mesh = NULL; + struct Mesh_Info *mesh = NULL; + + bu_vls_init(&name); + + if (argc != 3) { + bu_exit(1, "Usage: %s file.g object", argv[0]); + } + + dbip = db_open(argv[1], "r+w"); + if (dbip == DBI_NULL) { + bu_exit(1, "ERROR: Unable to read from %s\n", argv[1]); + } + + if (db_dirbuild(dbip) < 0) + bu_exit(1, "ERROR: Unable to read from %s\n", argv[1]); + + dp = db_lookup(dbip, argv[2], LOOKUP_QUIET); + if (dp == RT_DIR_NULL) { + bu_exit(1, "ERROR: Unable to look up object %s\n", argv[2]); + } + + RT_DB_INTERNAL_INIT(&intern) + if (rt_db_get_internal(&intern, dp, dbip, NULL, &rt_uniresource) < 0) { + bu_exit(1, "ERROR: Unable to get internal representation of %s\n", argv[2]); + } + + if (intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) { + bu_exit(1, "ERROR: object %s does not appear to be of type BoT\n", argv[2]); + } else { + bot_ip = (struct rt_bot_internal *)intern.idb_ptr; + } + RT_BOT_CK_MAGIC(bot_ip); + + for (size_t i_cnt = 1; i_cnt < 5; i_cnt++) { + struct bu_vls fname; + bu_vls_init(&fname); + bu_vls_printf(&fname, "root3_%d.pl", i_cnt); + FILE* plot_file = fopen(bu_vls_addr(&fname), "w"); + mesh = iterate(bot_ip, prev_mesh, plot_file); + prev_mesh = mesh; + fclose(plot_file); + } + + return 0; +} + +// Local Variables: +// tab-width: 8 +// mode: C++ +// c-basic-offset: 4 +// indent-tabs-mode: t +// c-file-style: "stroustrup" +// End: +// ex: shiftwidth=4 tabstop=8 Property changes on: brlcad/trunk/src/librt/test_subdivision.cpp ___________________________________________________________________ Added: svn:mime-type + text/plain Added: svn:eol-style + native This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[52989] brlcad/trunk/src/librt From: <n_reed@us...> - 2012-10-11 18:10 Revision: 52989 http://brlcad.svn.sourceforge.net/brlcad/?rev=52989&view=rev Author: n_reed Date: 2012-10-11 18:10:44 +0000 (Thu, 11 Oct 2012) Log Message: ----------- move routines that are going to be reused Modified Paths: -------------- brlcad/trunk/src/librt/librt_private.h brlcad/trunk/src/librt/primitives/ehy/ehy.c brlcad/trunk/src/librt/primitives/epa/epa.c brlcad/trunk/src/librt/primitives/primitive_util.c Modified: brlcad/trunk/src/librt/librt_private.h =================================================================== --- brlcad/trunk/src/librt/librt_private.h 2012-10-11 17:36:04 UTC (rev 52988) +++ brlcad/trunk/src/librt/librt_private.h 2012-10-11 18:10:44 UTC (rev 52989) @@ -99,6 +99,17 @@ struct rt_db_internal *ip, const struct rt_view_info *info); +extern int approximate_parabolic_curve( + struct rt_pt_node *pts, + fastf_t p, + int num_new_points); + +extern int approximate_hyperbolic_curve( + struct rt_pt_node *pts, + fastf_t a, + fastf_t b, + int num_new_points); + __END_DECLS /* Modified: brlcad/trunk/src/librt/primitives/ehy/ehy.c =================================================================== --- brlcad/trunk/src/librt/primitives/ehy/ehy.c 2012-10-11 17:36:04 UTC (rev 52988) +++ brlcad/trunk/src/librt/primitives/ehy/ehy.c 2012-10-11 18:10:44 UTC (rev 52989) @@ -674,129 +674,6 @@ return 0; } -/* Assume the existence of a line and a hyperbola with asymptote origin at the - * origin, both in the y-z plane (x = 0.0). The hyperbola and line are - * described by arguments a, b, and m, from the respective equations - * (z = +-(a/b) * sqrt(y^2 + b^2)) and (z = my + b). - * - * The line is assumed to intersect the positive half of the hyperbola at two - * points. - * - * The portion of the hyperbola between these two intersection points takes on - * a single maximum value with respect to the intersecting line when its slope - * is the same as the line's (i.e. when the tangent line and intersecting line - * are parallel). - * - * The first derivate slope equation z' = ay / (b * sqrt(y^2 + b^2)) implies - * that the hyperbola has slope m when y = mb^2 / sqrt(a^2 - b^2m^2). - * - * We calculate y from a, b, and m, and then z from y. - */ -static void -hyperbola_point_farthest_from_line(point_t max_point, fastf_t a, fastf_t b, fastf_t m) -{ - fastf_t y = (m * b * b) / sqrt((a * a) - (b * b * m * m)); - - max_point[X] = 0.0; - max_point[Y] = y; - max_point[Z] = (a / b) * sqrt(y * y + b * b); -} - -/* Calculate the length of the shortest distance between a point and a line in - * the y-z plane. - */ -static fastf_t -distance_point_to_line(point_t p, fastf_t slope, fastf_t intercept) -{ - /* input line: - * z = slope * y + intercept - * - * implicit form is: - * az + by + c = 0, where a = -slope, b = 1, c = -intercept - * - * standard 2D point-line distance calculation: - * d = |aPy + bPz + c| / sqrt(a^2 + b^2) - */ - return fabs(-slope * p[Y] + p[Z] - intercept) / sqrt(slope * slope + 1); -} - -/* Approximate part of the hyperbola lying in the Y-Z plane described by: - * ((z - k)^2 / a^2) - ((y - h)^2 / b^2) = 1 - * - * pts->p: the asymptote origin (0, h, k) - * pts->next->p: another point on the hyperbola - * pts->next->next: NULL - * a, b: the constants from the above equation - * - * This routine inserts num_new_points points between the two input points to - * better approximate the hyperbolic curve passing between them. - * - * Returns number of points successfully added. - */ -static int -approximate_hyperbolic_curve(struct rt_pt_node *pts, fastf_t a, fastf_t b, int num_new_points) -{ - fastf_t error, max_error, seg_slope, seg_intercept; - point_t v, point, p0, p1, new_point = VINIT_ZERO; - struct rt_pt_node *node, *worst_node, *new_node; - int i; - - if (pts == NULL || pts->next == NULL || num_new_points < 1) { - return 0; - } - - VMOVE(v, pts->p); - - for (i = 0; i < num_new_points; ++i) { - worst_node = node = pts; - max_error = 0.0; - - /* Find the least accurate line segment, and calculate a new hyperbola - * point to insert between it's endpoints. - */ - while (node->next != NULL) { - VMOVE(p0, node->p); - VMOVE(p1, node->next->p); - - seg_slope = (p1[Z] - p0[Z]) / (p1[Y] - p0[Y]); - seg_intercept = p0[Z] - seg_slope * p0[Y]; - - /* get farthest point on the equivalent hyperbola with asymptote origin at - * the origin - */ - hyperbola_point_farthest_from_line(point, a, b, seg_slope); - - /* translate result to actual hyperbola position */ - point[Y] += v[Y]; - point[Z] += v[Z] - a; - - /* see if the maximum distance between the hyperbola and the line - * (the error) is larger than the largest recorded error - * */ - error = distance_point_to_line(point, seg_slope, seg_intercept); - - if (error > max_error) { - max_error = error; - worst_node = node; - VMOVE(new_point, point); - } - - node = node->next; - } - - /* insert new point between endpoints of the least accurate segment */ - new_node = (struct rt_pt_node *)bu_malloc(sizeof(struct rt_pt_node), - "rt_pt_node"); - VMOVE(new_node->p, new_point); - new_node->next = worst_node->next; - worst_node->next = new_node; - - /* bu_log("%d: inserting %.2f between %.2f and %.2f\n", new_node->p[Z], worst_node->p[Z], new_node->p[Z]); */ - } - - return num_new_points; -} - /* Our canonical hyperbola in the Y-Z plane has equation * z = +- (a/b) * sqrt(b^2 + y^2), and opens toward +Z and -Z with asymptote * origin at the origin. Modified: brlcad/trunk/src/librt/primitives/epa/epa.c =================================================================== --- brlcad/trunk/src/librt/primitives/epa/epa.c 2012-10-11 17:36:04 UTC (rev 52988) +++ brlcad/trunk/src/librt/primitives/epa/epa.c 2012-10-11 18:10:44 UTC (rev 52989) @@ -656,121 +656,7 @@ return 0; } -/* Assume the existence of a line and a parabola at the origin, both in the y-z - * plane (x = 0.0). The parabola and line are described by arguments p and m, - * from the respective equations (z = y^2 / 4p) and (z = my + b). - * - * The line is assumed to intersect the parabola at two points. - * - * The portion of the parabola between these two intersection points takes on a - * single maximum value with respect to the intersecting line when its slope is - * the same as the line's (i.e. when the tangent line and intersecting line are - * parallel). - * - * The first derivate slope equation z' = y / 2p implies that the parabola has - * slope m when y = 2pm. So we calculate y from p and m, and then z from y. - */ -static void -parabola_point_farthest_from_line(point_t max_point, fastf_t p, fastf_t m) -{ - fastf_t y = 2.0 * p * m; - max_point[X] = 0.0; - max_point[Y] = y; - max_point[Z] = (y * y) / ( 4.0 * p); -} - -/* Calculate the length of the shortest distance between a point and a line in - * the y-z plane. - */ -static fastf_t -distance_point_to_line(point_t p, fastf_t slope, fastf_t intercept) -{ - /* input line: - * z = slope * y + intercept - * - * implicit form is: - * az + by + c = 0, where a = -slope, b = 1, c = -intercept - * - * standard 2D point-line distance calculation: - * d = |aPy + bPz + c| / sqrt(a^2 + b^2) - */ - return fabs(-slope * p[Y] + p[Z] - intercept) / sqrt(slope * slope + 1); -} - -/* Approximate part of the parabola (y - h)^2 = 4p(z - k) lying in the y-z - * plane. - * - * pts->p: the vertex (0, h, k) - * pts->next->p: another point on the parabola - * pts->next->next: NULL - * p: the constant from the above equation - * - * This routine inserts num_new_points points between the two input points to - * better approximate the parabolic curve passing between them. - * - * Returns number of points successfully added. - */ -static int -approximate_parabolic_curve(struct rt_pt_node *pts, fastf_t p, int num_new_points) -{ - fastf_t error, max_error, seg_slope, seg_intercept; - point_t v, point, p0, p1, new_point = VINIT_ZERO; - struct rt_pt_node *node, *worst_node, *new_node; - int i; - - if (pts == NULL || pts->next == NULL || num_new_points < 1) { - return 0; - } - - VMOVE(v, pts->p); - - for (i = 0; i < num_new_points; ++i) { - worst_node = node = pts; - max_error = 0.0; - - /* Find the least accurate line segment, and calculate a new parabola - * point to insert between it's endpoints. - */ - while (node->next != NULL) { - VMOVE(p0, node->p); - VMOVE(p1, node->next->p); - - seg_slope = (p1[Z] - p0[Z]) / (p1[Y] - p0[Y]); - seg_intercept = p0[Z] - seg_slope * p0[Y]; - - /* get farthest point on the equivalent parabola at the origin */ - parabola_point_farthest_from_line(point, p, seg_slope); - - /* translate result to actual parabola position */ - point[Y] += v[Y]; - point[Z] += v[Z]; - - /* see if the maximum distance between the parabola and the line - * (the error) is larger than the largest recorded error - * */ - error = distance_point_to_line(point, seg_slope, seg_intercept); - - if (error > max_error) { - max_error = error; - worst_node = node; - VMOVE(new_point, point); - } - - node = node->next; - } - - /* insert new point between endpoints of the least accurate segment */ - new_node = (struct rt_pt_node *)bu_malloc(sizeof(struct rt_pt_node), - "rt_pt_node"); - VMOVE(new_node->p, new_point); - new_node->next = worst_node->next; - worst_node->next = new_node; - } - - return num_new_points; -} - /* A canonical parabola in the Y-Z plane has equation z = y^2 / 4p, and opens * toward positive z with vertex at the origin. * Modified: brlcad/trunk/src/librt/primitives/primitive_util.c =================================================================== --- brlcad/trunk/src/librt/primitives/primitive_util.c 2012-10-11 17:36:04 UTC (rev 52988) +++ brlcad/trunk/src/librt/primitives/primitive_util.c 2012-10-11 18:10:44 UTC (rev 52989) @@ -92,3 +92,220 @@ return diagonal_samples; } +/* Calculate the length of the shortest distance between a point and a line in + * the y-z plane. + */ +static fastf_t +distance_point_to_line(point_t p, fastf_t slope, fastf_t intercept) +{ + /* input line: + * z = slope * y + intercept + * + * implicit form is: + * az + by + c = 0, where a = -slope, b = 1, c = -intercept + * + * standard 2D point-line distance calculation: + * d = |aPy + bPz + c| / sqrt(a^2 + b^2) + */ + return fabs(-slope * p[Y] + p[Z] - intercept) / sqrt(slope * slope + 1); +} + +/* Assume the existence of a line and a parabola at the origin, both in the y-z + * plane (x = 0.0). The parabola and line are described by arguments p and m, + * from the respective equations (z = y^2 / 4p) and (z = my + b). + * + * The line is assumed to intersect the parabola at two points. + * + * The portion of the parabola between these two intersection points takes on a + * single maximum value with respect to the intersecting line when its slope is + * the same as the line's (i.e. when the tangent line and intersecting line are + * parallel). + * + * The first derivate slope equation z' = y / 2p implies that the parabola has + * slope m when y = 2pm. So we calculate y from p and m, and then z from y. + */ +static void +parabola_point_farthest_from_line(point_t max_point, fastf_t p, fastf_t m) +{ + fastf_t y = 2.0 * p * m; + + max_point[X] = 0.0; + max_point[Y] = y; + max_point[Z] = (y * y) / ( 4.0 * p); +} + +/* Approximate part of the parabola (y - h)^2 = 4p(z - k) lying in the y-z + * plane. + * + * pts->p: the vertex (0, h, k) + * pts->next->p: another point on the parabola + * pts->next->next: NULL + * p: the constant from the above equation + * + * This routine inserts num_new_points points between the two input points to + * better approximate the parabolic curve passing between them. + * + * Returns number of points successfully added. + */ +int +approximate_parabolic_curve(struct rt_pt_node *pts, fastf_t p, int num_new_points) +{ + fastf_t error, max_error, seg_slope, seg_intercept; + point_t v, point, p0, p1, new_point = VINIT_ZERO; + struct rt_pt_node *node, *worst_node, *new_node; + int i; + + if (pts == NULL || pts->next == NULL || num_new_points < 1) { + return 0; + } + + VMOVE(v, pts->p); + + for (i = 0; i < num_new_points; ++i) { + worst_node = node = pts; + max_error = 0.0; + + /* Find the least accurate line segment, and calculate a new parabola + * point to insert between it's endpoints. + */ + while (node->next != NULL) { + VMOVE(p0, node->p); + VMOVE(p1, node->next->p); + + seg_slope = (p1[Z] - p0[Z]) / (p1[Y] - p0[Y]); + seg_intercept = p0[Z] - seg_slope * p0[Y]; + + /* get farthest point on the equivalent parabola at the origin */ + parabola_point_farthest_from_line(point, p, seg_slope); + + /* translate result to actual parabola position */ + point[Y] += v[Y]; + point[Z] += v[Z]; + + /* see if the maximum distance between the parabola and the line + * (the error) is larger than the largest recorded error + * */ + error = distance_point_to_line(point, seg_slope, seg_intercept); + + if (error > max_error) { + max_error = error; + worst_node = node; + VMOVE(new_point, point); + } + + node = node->next; + } + + /* insert new point between endpoints of the least accurate segment */ + new_node = (struct rt_pt_node *)bu_malloc(sizeof(struct rt_pt_node), + "rt_pt_node"); + VMOVE(new_node->p, new_point); + new_node->next = worst_node->next; + worst_node->next = new_node; + } + + return num_new_points; +} + +/* Assume the existence of a line and a hyperbola with asymptote origin at the + * origin, both in the y-z plane (x = 0.0). The hyperbola and line are + * described by arguments a, b, and m, from the respective equations + * (z = +-(a/b) * sqrt(y^2 + b^2)) and (z = my + b). + * + * The line is assumed to intersect the positive half of the hyperbola at two + * points. + * + * The portion of the hyperbola between these two intersection points takes on + * a single maximum value with respect to the intersecting line when its slope + * is the same as the line's (i.e. when the tangent line and intersecting line + * are parallel). + * + * The first derivate slope equation z' = ay / (b * sqrt(y^2 + b^2)) implies + * that the hyperbola has slope m when y = mb^2 / sqrt(a^2 - b^2m^2). + * + * We calculate y from a, b, and m, and then z from y. + */ +static void +hyperbola_point_farthest_from_line(point_t max_point, fastf_t a, fastf_t b, fastf_t m) +{ + fastf_t y = (m * b * b) / sqrt((a * a) - (b * b * m * m)); + + max_point[X] = 0.0; + max_point[Y] = y; + max_point[Z] = (a / b) * sqrt(y * y + b * b); +} + +/* Approximate part of the hyperbola lying in the Y-Z plane described by: + * ((z - k)^2 / a^2) - ((y - h)^2 / b^2) = 1 + * + * pts->p: the asymptote origin (0, h, k) + * pts->next->p: another point on the hyperbola + * pts->next->next: NULL + * a, b: the constants from the above equation + * + * This routine inserts num_new_points points between the two input points to + * better approximate the hyperbolic curve passing between them. + * + * Returns number of points successfully added. + */ +int +approximate_hyperbolic_curve(struct rt_pt_node *pts, fastf_t a, fastf_t b, int num_new_points) +{ + fastf_t error, max_error, seg_slope, seg_intercept; + point_t v, point, p0, p1, new_point = VINIT_ZERO; + struct rt_pt_node *node, *worst_node, *new_node; + int i; + + if (pts == NULL || pts->next == NULL || num_new_points < 1) { + return 0; + } + + VMOVE(v, pts->p); + + for (i = 0; i < num_new_points; ++i) { + worst_node = node = pts; + max_error = 0.0; + + /* Find the least accurate line segment, and calculate a new hyperbola + * point to insert between it's endpoints. + */ + while (node->next != NULL) { + VMOVE(p0, node->p); + VMOVE(p1, node->next->p); + + seg_slope = (p1[Z] - p0[Z]) / (p1[Y] - p0[Y]); + seg_intercept = p0[Z] - seg_slope * p0[Y]; + + /* get farthest point on the equivalent hyperbola with asymptote origin at + * the origin + */ + hyperbola_point_farthest_from_line(point, a, b, seg_slope); + + /* translate result to actual hyperbola position */ + point[Y] += v[Y]; + point[Z] += v[Z] - a; + + /* see if the maximum distance between the hyperbola and the line + * (the error) is larger than the largest recorded error + * */ + error = distance_point_to_line(point, seg_slope, seg_intercept); + + if (error > max_error) { + max_error = error; + worst_node = node; + VMOVE(new_point, point); + } + + node = node->next; + } + + /* insert new point between endpoints of the least accurate segment */ + new_node = (struct rt_pt_node *)bu_malloc(sizeof(struct rt_pt_node), + "rt_pt_node"); + VMOVE(new_node->p, new_point); + new_node->next = worst_node->next; + worst_node->next = new_node; + } + + return num_new_points; +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53055] brlcad/trunk/src/librt From: <n_reed@us...> - 2012-10-16 13:48 Revision: 53055 http://brlcad.svn.sourceforge.net/brlcad/?rev=53055&view=rev Author: n_reed Date: 2012-10-16 13:48:35 +0000 (Tue, 16 Oct 2012) Log Message: ----------- add general ellipse plotting routine Modified Paths: -------------- brlcad/trunk/src/librt/librt_private.h brlcad/trunk/src/librt/primitives/primitive_util.c Modified: brlcad/trunk/src/librt/librt_private.h =================================================================== --- brlcad/trunk/src/librt/librt_private.h 2012-10-16 13:21:46 UTC (rev 53054) +++ brlcad/trunk/src/librt/librt_private.h 2012-10-16 13:48:35 UTC (rev 53055) @@ -110,6 +110,13 @@ fastf_t b, int num_new_points); +extern void plot_ellipse( + struct bu_list *vhead, + vect_t t, + vect_t a, + vect_t b, + int num_points); + __END_DECLS /* Modified: brlcad/trunk/src/librt/primitives/primitive_util.c =================================================================== --- brlcad/trunk/src/librt/primitives/primitive_util.c 2012-10-16 13:21:46 UTC (rev 53054) +++ brlcad/trunk/src/librt/primitives/primitive_util.c 2012-10-16 13:48:35 UTC (rev 53055) @@ -309,3 +309,45 @@ return num_new_points; } + +static void +ellipse_point_at_radian( + point_t result, + vect_t t, + vect_t a, + vect_t b, + fastf_t radian) +{ + fastf_t cos_rad, sin_rad; + + cos_rad = cos(radian); + sin_rad = sin(radian); + + VJOIN2(result, t, cos_rad, a, sin_rad, b); +} + +void +plot_ellipse( + struct bu_list *vhead, + vect_t t, + vect_t a, + vect_t b, + int num_points) +{ + int i; + point_t p; + fastf_t radian, radian_step; + + radian_step = bn_twopi / num_points; + + ellipse_point_at_radian(p, t, a, b, radian_step * (num_points - 1)); + RT_ADD_VLIST(vhead, p, BN_VLIST_LINE_MOVE); + + radian = 0; + for (i = 0; i < num_points; ++i) { + ellipse_point_at_radian(p, t, a, b, radian); + RT_ADD_VLIST(vhead, p, BN_VLIST_LINE_DRAW); + + radian += radian_step; + } +} This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53057] brlcad/trunk/src/librt From: <n_reed@us...> - 2012-10-16 14:11 Revision: 53057 http://brlcad.svn.sourceforge.net/brlcad/?rev=53057&view=rev Author: n_reed Date: 2012-10-16 14:11:49 +0000 (Tue, 16 Oct 2012) Log Message: ----------- expose helper routine and rename parameters Modified Paths: -------------- brlcad/trunk/src/librt/librt_private.h brlcad/trunk/src/librt/primitives/primitive_util.c Modified: brlcad/trunk/src/librt/librt_private.h =================================================================== --- brlcad/trunk/src/librt/librt_private.h 2012-10-16 13:53:35 UTC (rev 53056) +++ brlcad/trunk/src/librt/librt_private.h 2012-10-16 14:11:49 UTC (rev 53057) @@ -110,6 +110,14 @@ fastf_t b, int num_new_points); +extern void +ellipse_point_at_radian( + point_t result, + vect_t center, + vect_t axis_a, + vect_t axis_b, + fastf_t radian); + extern void plot_ellipse( struct bu_list *vhead, vect_t t, Modified: brlcad/trunk/src/librt/primitives/primitive_util.c =================================================================== --- brlcad/trunk/src/librt/primitives/primitive_util.c 2012-10-16 13:53:35 UTC (rev 53056) +++ brlcad/trunk/src/librt/primitives/primitive_util.c 2012-10-16 14:11:49 UTC (rev 53057) @@ -310,12 +310,12 @@ return num_new_points; } -static void +void ellipse_point_at_radian( point_t result, - vect_t t, - vect_t a, - vect_t b, + vect_t center, + vect_t axis_a, + vect_t axis_b, fastf_t radian) { fastf_t cos_rad, sin_rad; @@ -323,15 +323,15 @@ cos_rad = cos(radian); sin_rad = sin(radian); - VJOIN2(result, t, cos_rad, a, sin_rad, b); + VJOIN2(result, center, cos_rad, axis_a, sin_rad, axis_b); } void plot_ellipse( struct bu_list *vhead, - vect_t t, - vect_t a, - vect_t b, + vect_t center, + vect_t axis_a, + vect_t axis_b, int num_points) { int i; @@ -340,12 +340,13 @@ radian_step = bn_twopi / num_points; - ellipse_point_at_radian(p, t, a, b, radian_step * (num_points - 1)); + ellipse_point_at_radian(p, center, axis_a, axis_b, + radian_step * (num_points - 1)); RT_ADD_VLIST(vhead, p, BN_VLIST_LINE_MOVE); radian = 0; for (i = 0; i < num_points; ++i) { - ellipse_point_at_radian(p, t, a, b, radian); + ellipse_point_at_radian(p, center, axis_a, axis_b, radian); RT_ADD_VLIST(vhead, p, BN_VLIST_LINE_DRAW); radian += radian_step; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53401] brlcad/trunk/src/librt From: <brlcad@us...> - 2012-10-30 02:12 Revision: 53401 http://brlcad.svn.sourceforge.net/brlcad/?rev=53401&view=rev Author: brlcad Date: 2012-10-30 02:12:38 +0000 (Tue, 30 Oct 2012) Log Message: ----------- big whoosh repair of the assumption that fastf_t are doubles. critically, all import/export routines CANNOT be fastf_t since that's intended to be a variadic type (that's why there's a typedef). we have to convert fastf_t to double before export and after import. use the ELEMENTS_PER_* defines to convey the type where appropiate and helpful for documenting intent. Modified Paths: -------------- brlcad/trunk/src/librt/binunif/db5_bin.c brlcad/trunk/src/librt/comb/comb.c brlcad/trunk/src/librt/db_match.c brlcad/trunk/src/librt/primitives/arb8/arb8.c brlcad/trunk/src/librt/primitives/arbn/arbn.c brlcad/trunk/src/librt/primitives/ars/ars.c brlcad/trunk/src/librt/primitives/bot/bot.c brlcad/trunk/src/librt/primitives/bspline/bspline.cpp brlcad/trunk/src/librt/primitives/cline/cline.c brlcad/trunk/src/librt/primitives/dsp/dsp.c brlcad/trunk/src/librt/primitives/ehy/ehy.c brlcad/trunk/src/librt/primitives/ell/ell.c brlcad/trunk/src/librt/primitives/epa/epa.c brlcad/trunk/src/librt/primitives/eto/eto.c brlcad/trunk/src/librt/primitives/extrude/extrude.c brlcad/trunk/src/librt/primitives/grip/grip.c brlcad/trunk/src/librt/primitives/half/half.c brlcad/trunk/src/librt/primitives/hyp/hyp.c brlcad/trunk/src/librt/primitives/metaball/metaball.c brlcad/trunk/src/librt/primitives/nmg/nmg.c brlcad/trunk/src/librt/primitives/part/part.c brlcad/trunk/src/librt/primitives/pipe/pipe.c brlcad/trunk/src/librt/primitives/pnts/pnts.c brlcad/trunk/src/librt/primitives/revolve/revolve.c brlcad/trunk/src/librt/primitives/rhc/rhc.c brlcad/trunk/src/librt/primitives/rpc/rpc.c brlcad/trunk/src/librt/primitives/sketch/sketch.c brlcad/trunk/src/librt/primitives/tgc/tgc.c brlcad/trunk/src/librt/primitives/tor/tor.c brlcad/trunk/src/librt/primitives/xxx/xxx.c brlcad/trunk/src/librt/vlist.c Modified: brlcad/trunk/src/librt/binunif/db5_bin.c =================================================================== --- brlcad/trunk/src/librt/binunif/db5_bin.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/binunif/db5_bin.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -161,8 +161,7 @@ bip->count = ep->ext_nbytes/SIZEOF_NETWORK_DOUBLE; bip->u.uint8 = (unsigned char *) bu_malloc( bip->count * sizeof(double), "rt_binunif_internal" ); - ntohd( (unsigned char *) bip->u.uint8, - ep->ext_buf, bip->count ); + ntohd( (unsigned char *) bip->u.uint8, ep->ext_buf, bip->count ); break; case DB5_MINORTYPE_BINU_8BITINT: case DB5_MINORTYPE_BINU_8BITINT_U: Modified: brlcad/trunk/src/librt/comb/comb.c =================================================================== --- brlcad/trunk/src/librt/comb/comb.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/comb/comb.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -195,9 +195,11 @@ /* Encoding of the matrix */ if (mi != (ssize_t)-1) { - htond(ssp->matp, - (const unsigned char *)tp->tr_l.tl_mat, - ELEMENTS_PER_MAT); + /* must be double for import and export */ + double scanmat[ELEMENTS_PER_MAT]; + + MAT_COPY(scanmat, tp->tr_l.tl_mat); /* convert fastf_t to double */ + htond(ssp->matp, (const unsigned char *)scanmat, ELEMENTS_PER_MAT); ssp->matp += ELEMENTS_PER_MAT * SIZEOF_NETWORK_DOUBLE; } @@ -543,11 +545,16 @@ } else { mat_t diskmat; + /* must be double for import and export */ + double scanmat[16]; + /* Unpack indicated matrix mi */ BU_ASSERT_SIZE_T(mi, <, nmat); - ntohd((unsigned char *)diskmat, - &matp[mi*ELEMENTS_PER_MAT*SIZEOF_NETWORK_DOUBLE], - ELEMENTS_PER_MAT); + + /* read matrix */ + ntohd((unsigned char *)scanmat, &matp[mi*ELEMENTS_PER_MAT*SIZEOF_NETWORK_DOUBLE], ELEMENTS_PER_MAT); + MAT_COPY(diskmat, scanmat); /* convert double to fastf_t */ + if (!mat || bn_mat_is_identity(mat)) { tp->tr_l.tl_mat = bn_mat_dup(diskmat); } else { @@ -661,11 +668,16 @@ } else { mat_t diskmat; + /* must be double for import and export */ + double scanmat[16]; + /* Unpack indicated matrix mi */ BU_ASSERT_SIZE_T(mi, <, nmat); - ntohd((unsigned char *)diskmat, - &matp[mi*ELEMENTS_PER_MAT*SIZEOF_NETWORK_DOUBLE], - ELEMENTS_PER_MAT); + + /* read matrix */ + ntohd((unsigned char *)scanmat, &matp[mi*ELEMENTS_PER_MAT*SIZEOF_NETWORK_DOUBLE], ELEMENTS_PER_MAT); + MAT_COPY(diskmat, scanmat); /* convert double to fastf_t */ + if (!mat || bn_mat_is_identity(mat)) { tp->tr_l.tl_mat = bn_mat_dup(diskmat); } else { Modified: brlcad/trunk/src/librt/db_match.c =================================================================== --- brlcad/trunk/src/librt/db_match.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/db_match.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -137,10 +137,13 @@ if (dp->d_major_type == DB5_MAJORTYPE_BRLCAD) { struct directory *dp2; + /* initialize for good measure */ + RT_DB_INTERNAL_INIT(&intern); + if (dp->d_minor_type == DB5_MINORTYPE_BRLCAD_EXTRUDE) { struct rt_extrude_internal *extr; - if (rt_db_get_internal(&intern, dp, dbip, (fastf_t *)NULL, resp) < 0) + if (rt_db_get_internal(&intern, dp, dbip, NULL, resp) < 0) continue; extr = (struct rt_extrude_internal *)intern.idb_ptr; RT_EXTRUDE_CK_MAGIC(extr); @@ -154,7 +157,7 @@ } else if (dp->d_minor_type == DB5_MINORTYPE_BRLCAD_REVOLVE) { struct rt_revolve_internal *revolve; - if (rt_db_get_internal(&intern, dp, dbip, (fastf_t *)NULL, resp) < 0) + if (rt_db_get_internal(&intern, dp, dbip, NULL, resp) < 0) continue; revolve = (struct rt_revolve_internal *)intern.idb_ptr; RT_REVOLVE_CK_MAGIC(revolve); @@ -168,7 +171,7 @@ } else if (dp->d_minor_type == DB5_MINORTYPE_BRLCAD_DSP) { struct rt_dsp_internal *dsp; - if (rt_db_get_internal(&intern, dp, dbip, (fastf_t *)NULL, resp) < 0) + if (rt_db_get_internal(&intern, dp, dbip, NULL, resp) < 0) continue; dsp = (struct rt_dsp_internal *)intern.idb_ptr; RT_DSP_CK_MAGIC(dsp); @@ -183,7 +186,7 @@ } if (!(dp->d_flags & RT_DIR_COMB)) continue; - if (rt_db_get_internal(&intern, dp, dbip, (fastf_t *)NULL, resp) < 0) + if (rt_db_get_internal(&intern, dp, dbip, NULL, resp) < 0) continue; if (intern.idb_type != ID_COMBINATION) { bu_log("NOTICE: %s was marked a combination, but isn't one? Clearing flag\n", Modified: brlcad/trunk/src/librt/primitives/arb8/arb8.c =================================================================== --- brlcad/trunk/src/librt/primitives/arb8/arb8.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/arb8/arb8.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1262,8 +1262,10 @@ { struct rt_arb_internal *aip; register int i; - fastf_t vec[3*8]; + /* must be double for import and export */ + double vec[3*8]; + RT_CK_DB_INTERNAL(ip); BU_CK_EXTERNAL(ep); if (dbip) RT_CK_DBI(dbip); @@ -1295,9 +1297,11 @@ rt_arb_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_arb_internal *aip; - fastf_t vec[3*8]; register int i; + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT*8]; + RT_CK_DB_INTERNAL(ip); if (dbip) RT_CK_DBI(dbip); @@ -1306,12 +1310,12 @@ RT_ARB_CK_MAGIC(aip); BU_CK_EXTERNAL(ep); - ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE * 8 * 3; + ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE * 8 * ELEMENTS_PER_VECT; ep->ext_buf = (genptr_t)bu_malloc(ep->ext_nbytes, "arb external"); for (i=0; i<8; i++) { - VSCALE(&vec[i*3], aip->pt[i], local2mm); + VSCALE(&vec[i*ELEMENTS_PER_VECT], aip->pt[i], local2mm); } - htond(ep->ext_buf, (unsigned char *)vec, 8*3); + htond(ep->ext_buf, (unsigned char *)vec, 8*ELEMENTS_PER_VECT); return 0; } Modified: brlcad/trunk/src/librt/primitives/arbn/arbn.c =================================================================== --- brlcad/trunk/src/librt/primitives/arbn/arbn.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/arbn/arbn.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -829,6 +829,9 @@ struct rt_arbn_internal *aip; size_t i; + /* must be double for import and export */ + double *scan; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -847,9 +850,18 @@ aip->magic = RT_ARBN_INTERNAL_MAGIC; aip->neqn = ntohl(*(uint32_t *)rp->n.n_neqn); if (aip->neqn <= 0) return -1; + aip->eqn = (plane_t *)bu_malloc(aip->neqn*sizeof(plane_t), "arbn plane eqn[]"); + scan = (double *)bu_malloc(aip->neqn*sizeof(double)*ELEMENTS_PER_PLANE, "scan array"); - ntohd((unsigned char *)aip->eqn, (unsigned char *)(&rp[1]), aip->neqn*4); + ntohd((unsigned char *)scan, (unsigned char *)(&rp[1]), aip->neqn*ELEMENTS_PER_PLANE); + for (i=0; i<aip->neqn; i++) { + aip->eqn[i][X] = scan[(i*ELEMENTS_PER_PLANE)+0]; /* convert double to fastf_t */ + aip->eqn[i][Y] = scan[(i*ELEMENTS_PER_PLANE)+1]; /* convert double to fastf_t */ + aip->eqn[i][Z] = scan[(i*ELEMENTS_PER_PLANE)+2]; /* convert double to fastf_t */ + aip->eqn[i][W] = scan[(i*ELEMENTS_PER_PLANE)+3]; /* convert double to fastf_t */ + } + bu_free(scan, "scan array"); /* Transform by the matrix */ if (mat == NULL) mat = bn_mat_identity; @@ -891,10 +903,12 @@ struct rt_arbn_internal *aip; union record *rec; size_t ngrans; - double *sbuf; /* scalling buffer */ - double *sp; size_t i; + /* scaling buffer must be double, not fastf_t */ + double *sbuf; + double *sp; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); @@ -908,7 +922,7 @@ * The network format for a double is 8 bytes and there are 4 * doubles per plane equation. */ - ngrans = (aip->neqn * 8 * 4 + sizeof(union record)-1) / + ngrans = (aip->neqn * 8 * ELEMENTS_PER_PLANE + sizeof(union record)-1) / sizeof(union record); BU_CK_EXTERNAL(ep); @@ -922,7 +936,7 @@ /* Take the data from the caller, and scale it, into sbuf */ sp = sbuf = (double *)bu_malloc( - aip->neqn * sizeof(double) * 4, "arbn temp"); + aip->neqn * sizeof(double) * ELEMENTS_PER_PLANE, "arbn temp"); for (i=0; i<aip->neqn; i++) { /* Normal is unscaled, should have unit length; d is scaled */ *sp++ = aip->eqn[i][X]; @@ -931,7 +945,7 @@ *sp++ = aip->eqn[i][W] * local2mm; } - htond((unsigned char *)&rec[1], (unsigned char *)sbuf, aip->neqn * 4); + htond((unsigned char *)&rec[1], (unsigned char *)sbuf, aip->neqn * ELEMENTS_PER_PLANE); bu_free((char *)sbuf, "arbn temp"); return 0; /* OK */ @@ -952,6 +966,8 @@ unsigned long neqn; int double_count; size_t byte_count; + + /* must be double for import and export */ double *eqn; RT_CK_DB_INTERNAL(ip); @@ -975,7 +991,7 @@ if (aip->neqn <= 0) return -1; eqn = (double *)bu_malloc(byte_count, "arbn plane eqn[] temp buf"); - ntohd((unsigned char *)eqn, (unsigned char *)ep->ext_buf + 4, double_count); + ntohd((unsigned char *)eqn, (unsigned char *)ep->ext_buf + ELEMENTS_PER_PLANE, double_count); aip->eqn = (plane_t *)bu_malloc(double_count * sizeof(fastf_t), "arbn plane eqn[]"); for (i=0; i < aip->neqn; i++) { HMOVE(aip->eqn[i], &eqn[i*ELEMENTS_PER_PLANE]); @@ -1021,11 +1037,13 @@ { struct rt_arbn_internal *aip; size_t i; - double *vec; - double *sp; int double_count; int byte_count; + /* must be double for export */ + double *vec; + double *sp; + RT_CK_DB_INTERNAL(ip); if (dbip) RT_CK_DBI(dbip); @@ -1039,7 +1057,7 @@ byte_count = double_count * SIZEOF_NETWORK_DOUBLE; BU_CK_EXTERNAL(ep); - ep->ext_nbytes = 4 + byte_count; + ep->ext_nbytes = SIZEOF_NETWORK_LONG + byte_count; ep->ext_buf = (genptr_t)bu_malloc(ep->ext_nbytes, "arbn external"); *(uint32_t *)ep->ext_buf = htonl(aip->neqn); @@ -1055,7 +1073,7 @@ } /* Convert from internal (host) to database (network) format */ - htond((unsigned char *)ep->ext_buf + 4, (unsigned char *)vec, double_count); + htond((unsigned char *)ep->ext_buf + SIZEOF_NETWORK_LONG, (unsigned char *)vec, double_count); bu_free((char *)vec, "arbn temp"); return 0; /* OK */ @@ -1218,7 +1236,7 @@ i * sizeof(plane_t), "arbn->eqn"); for (j=arbn->neqn; j<i; j++) { - VSETALLN(arbn->eqn[j], 0.0, 4); + HSETALL(arbn->eqn[j], 0.0); } arbn->neqn = i; @@ -1233,7 +1251,7 @@ len = 0; (void)tcl_list_to_fastf_array(brlcad_interp, argv[1], &new_planes, &len); - if (len%4) { + if (len%ELEMENTS_PER_PLANE) { bu_vls_printf(logstr, "ERROR: Incorrect number of plane coefficients\n"); if (len) @@ -1243,7 +1261,7 @@ if (arbn->eqn) bu_free((char *)arbn->eqn, "arbn->eqn"); arbn->eqn = (plane_t *)new_planes; - arbn->neqn = (size_t)len / 4; + arbn->neqn = (size_t)len / ELEMENTS_PER_PLANE; for (i=0; i<arbn->neqn; i++) VUNITIZE(arbn->eqn[i]); } else if (argv[0][0] == 'P') { @@ -1264,10 +1282,10 @@ bu_vls_printf(logstr, "ERROR: plane number out of range\n"); return BRLCAD_ERROR; } - len = 4; + len = ELEMENTS_PER_PLANE; array = (fastf_t *)&arbn->eqn[i]; if (tcl_list_to_fastf_array(brlcad_interp, argv[1], - &array, &len) != 4) { + &array, &len) != ELEMENTS_PER_PLANE) { bu_vls_printf(logstr, "ERROR: incorrect number of coefficients for a plane\n"); return BRLCAD_ERROR; Modified: brlcad/trunk/src/librt/primitives/ars/ars.c =================================================================== --- brlcad/trunk/src/librt/primitives/ars/ars.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/ars/ars.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -314,9 +314,11 @@ struct rt_ars_internal *ari; register size_t i, j; register unsigned char *cp; - vect_t tmp_vec; register fastf_t *fp; + /* must be double for import and export */ + double tmp_pnt[ELEMENTS_PER_POINT]; + RT_CK_DB_INTERNAL(ip); BU_CK_EXTERNAL(ep); if (dbip) RT_CK_DBI(dbip); @@ -342,14 +344,14 @@ (ari->ncurves+1), sizeof(fastf_t *), "ars curve ptrs"); if (mat == NULL) mat = bn_mat_identity; for (i=0; i < ari->ncurves; i++) { - ari->curves[i] = (fastf_t *)bu_calloc((ari->pts_per_curve + 1) * 3, + ari->curves[i] = (fastf_t *)bu_calloc((ari->pts_per_curve + 1) * ELEMENTS_PER_POINT, sizeof(fastf_t), "ARS points"); fp = ari->curves[i]; for (j=0; j<ari->pts_per_curve; j++) { - ntohd((unsigned char *)tmp_vec, cp, 3); - MAT4X3PNT(fp, mat, tmp_vec); - cp += 3 * SIZEOF_NETWORK_DOUBLE; - fp += ELEMENTS_PER_VECT; + ntohd((unsigned char *)tmp_pnt, cp, ELEMENTS_PER_POINT); + MAT4X3PNT(fp, mat, tmp_pnt); + cp += ELEMENTS_PER_POINT * SIZEOF_NETWORK_DOUBLE; + fp += ELEMENTS_PER_POINT; } VMOVE(fp, ari->curves[i]); /* duplicate first point */ } @@ -368,9 +370,11 @@ { struct rt_ars_internal *arip; unsigned char *cp; - vect_t tmp_vec; size_t cur; /* current curve number */ + /* must be double for import and export */ + double tmp_pnt[ELEMENTS_PER_POINT]; + RT_CK_DB_INTERNAL(ip); if (ip->idb_type != ID_ARS) return -1; arip = (struct rt_ars_internal *)ip->idb_ptr; @@ -379,8 +383,7 @@ if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); - ep->ext_nbytes = 2 * SIZEOF_NETWORK_LONG + - 3 * arip->ncurves * arip->pts_per_curve * SIZEOF_NETWORK_DOUBLE; + ep->ext_nbytes = 2 * SIZEOF_NETWORK_LONG + ELEMENTS_PER_POINT * arip->ncurves * arip->pts_per_curve * SIZEOF_NETWORK_DOUBLE; ep->ext_buf = (genptr_t)bu_calloc(1, ep->ext_nbytes, "ars external"); cp = (unsigned char *)ep->ext_buf; @@ -395,10 +398,10 @@ fp = arip->curves[cur]; for (npts=0; npts < arip->pts_per_curve; npts++) { - VSCALE(tmp_vec, fp, local2mm); - ntohd(cp, (unsigned char *)tmp_vec, 3); - cp += 3 * SIZEOF_NETWORK_DOUBLE; - fp += ELEMENTS_PER_VECT; + VSCALE(tmp_pnt, fp, local2mm); + htond(cp, (unsigned char *)tmp_pnt, ELEMENTS_PER_POINT); + cp += ELEMENTS_PER_POINT * SIZEOF_NETWORK_DOUBLE; + fp += ELEMENTS_PER_POINT; } } return 0; Modified: brlcad/trunk/src/librt/primitives/bot/bot.c =================================================================== --- brlcad/trunk/src/librt/primitives/bot/bot.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/bot/bot.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -781,29 +781,33 @@ if (mat == NULL) mat = bn_mat_identity; for (i = 0; i < bot_ip->num_vertices; i++) { - point_t tmp; + double tmp[ELEMENTS_PER_POINT]; - ntohd((unsigned char *)tmp, (const unsigned char *)(&rp->bot.bot_data[i*24]), 3); - MAT4X3PNT(&(bot_ip->vertices[i*3]), mat, tmp); + ntohd((unsigned char *)tmp, (const unsigned char *)(&rp->bot.bot_data[i*24]), ELEMENTS_PER_POINT); + MAT4X3PNT(&(bot_ip->vertices[i*ELEMENTS_PER_POINT]), mat, tmp); } - chars_used = bot_ip->num_vertices * 3 * 8; + chars_used = bot_ip->num_vertices * ELEMENTS_PER_POINT * 8; for (i = 0; i < bot_ip->num_faces; i++) { size_t idx=chars_used + i * 12; - bot_ip->faces[i*3 + 0] = ntohl(*(uint32_t *)&rp->bot.bot_data[idx + 0]); - bot_ip->faces[i*3 + 1] = ntohl(*(uint32_t *)&rp->bot.bot_data[idx + 4]); - bot_ip->faces[i*3 + 2] = ntohl(*(uint32_t *)&rp->bot.bot_data[idx + 8]); + bot_ip->faces[i*ELEMENTS_PER_POINT + 0] = ntohl(*(uint32_t *)&rp->bot.bot_data[idx + 0]); + bot_ip->faces[i*ELEMENTS_PER_POINT + 1] = ntohl(*(uint32_t *)&rp->bot.bot_data[idx + 4]); + bot_ip->faces[i*ELEMENTS_PER_POINT + 2] = ntohl(*(uint32_t *)&rp->bot.bot_data[idx + 8]); } if (bot_ip->mode == RT_BOT_PLATE || bot_ip->mode == RT_BOT_PLATE_NOCOS) { - chars_used = bot_ip->num_vertices * 3 * 8 + bot_ip->num_faces * 12; + chars_used = bot_ip->num_vertices * ELEMENTS_PER_POINT * 8 + bot_ip->num_faces * 12; bot_ip->thickness = (fastf_t *)bu_calloc(bot_ip->num_faces, sizeof(fastf_t), "BOT thickness"); - for (i = 0; i < bot_ip->num_faces; i++) - ntohd((unsigned char *)&(bot_ip->thickness[i]), - (const unsigned char *)(&rp->bot.bot_data[chars_used + i*8]), 1); + for (i = 0; i < bot_ip->num_faces; i++) { + double scan; + + ntohd((unsigned char *)&scan, (const unsigned char *)(&rp->bot.bot_data[chars_used + i*8]), 1); + bot_ip->thickness[i] = scan; /* convert double to fastf_t */ + } + bot_ip->face_mode = bu_hex_to_bitv((const char *)(&rp->bot.bot_data[chars_used + bot_ip->num_faces * 8])); } else { bot_ip->thickness = (fastf_t *)NULL; @@ -842,7 +846,7 @@ BU_CK_EXTERNAL(ep); ep->ext_nbytes = sizeof(struct bot_rec) - 1 + - bot_ip->num_vertices * 3 * 8 + bot_ip->num_faces * 3 * 4; + bot_ip->num_vertices * ELEMENTS_PER_POINT * 8 + bot_ip->num_faces * ELEMENTS_PER_POINT * 4; if (bot_ip->mode == RT_BOT_PLATE || bot_ip->mode == RT_BOT_PLATE_NOCOS) { if (!bot_ip->face_mode) { bot_ip->face_mode = bu_bitv_new(bot_ip->num_faces); @@ -881,10 +885,11 @@ * record format */ for (i = 0; i < bot_ip->num_vertices; i++) { - point_t tmp; + /* must be double for import and export */ + double tmp[ELEMENTS_PER_POINT]; - VSCALE(tmp, &bot_ip->vertices[i*3], local2mm); - htond((unsigned char *)&rec->bot.bot_data[i*24], (const unsigned char *)tmp, 3); + VSCALE(tmp, &bot_ip->vertices[i*ELEMENTS_PER_POINT], local2mm); + htond((unsigned char *)&rec->bot.bot_data[i*24], (const unsigned char *)tmp, ELEMENTS_PER_POINT); } chars_used = bot_ip->num_vertices * 24; @@ -892,16 +897,18 @@ for (i = 0; i < bot_ip->num_faces; i++) { size_t idx=chars_used + i * 12; - *(uint32_t *)&rec->bot.bot_data[idx + 0] = htonl(bot_ip->faces[i*3+0]); - *(uint32_t *)&rec->bot.bot_data[idx + 4] = htonl(bot_ip->faces[i*3+1]); - *(uint32_t *)&rec->bot.bot_data[idx + 8] = htonl(bot_ip->faces[i*3+2]); + *(uint32_t *)&rec->bot.bot_data[idx + 0] = htonl(bot_ip->faces[i*ELEMENTS_PER_POINT+0]); + *(uint32_t *)&rec->bot.bot_data[idx + 4] = htonl(bot_ip->faces[i*ELEMENTS_PER_POINT+1]); + *(uint32_t *)&rec->bot.bot_data[idx + 8] = htonl(bot_ip->faces[i*ELEMENTS_PER_POINT+2]); } chars_used += bot_ip->num_faces * 12; if (bot_ip->mode == RT_BOT_PLATE || bot_ip->mode == RT_BOT_PLATE_NOCOS) { for (i = 0; i < bot_ip->num_faces; i++) { - fastf_t tmp; + /* must be double for import and export */ + double tmp; + tmp = bot_ip->thickness[i] * local2mm; htond((unsigned char *)&rec->bot.bot_data[chars_used], (const unsigned char *)&tmp, 1); chars_used += 8; @@ -946,7 +953,7 @@ bip->bot_flags = *cp++; if (bip->num_vertices > 0) { - bip->vertices = (fastf_t *)bu_calloc(bip->num_vertices * 3, sizeof(fastf_t), "BOT vertices"); + bip->vertices = (fastf_t *)bu_calloc(bip->num_vertices * ELEMENTS_PER_POINT, sizeof(fastf_t), "BOT vertices"); } else { bip->vertices = (fastf_t *)NULL; } @@ -966,11 +973,12 @@ mat = bn_mat_identity; for (i = 0; i < bip->num_vertices; i++) { - point_t tmp; + /* must be double for import and export */ + double tmp[ELEMENTS_PER_POINT]; - ntohd((unsigned char *)tmp, (const unsigned char *)cp, 3); - cp += SIZEOF_NETWORK_DOUBLE * 3; - MAT4X3PNT(&(bip->vertices[i*3]), mat, tmp); + ntohd((unsigned char *)tmp, (const unsigned char *)cp, ELEMENTS_PER_POINT); + cp += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_POINT; + MAT4X3PNT(&(bip->vertices[i*ELEMENTS_PER_POINT]), mat, tmp); } for (i = 0; i < bip->num_faces; i++) { @@ -985,7 +993,9 @@ if (bip->mode == RT_BOT_PLATE || bip->mode == RT_BOT_PLATE_NOCOS) { bip->thickness = (fastf_t *)bu_calloc(bip->num_faces, sizeof(fastf_t), "BOT thickness"); for (i = 0; i < bip->num_faces; i++) { - ntohd((unsigned char *)&(bip->thickness[i]), cp, 1); + double scan; + ntohd((unsigned char *)&scan, cp, 1); + bip->thickness[i] = scan; /* convert double to fastf_t */ cp += SIZEOF_NETWORK_DOUBLE; } bip->face_mode = bu_hex_to_bitv((const char *)cp); @@ -996,7 +1006,8 @@ } if (bip->bot_flags & RT_BOT_HAS_SURFACE_NORMALS) { - vect_t tmp; + /* must be double for import and export */ + double tmp[ELEMENTS_PER_VECT]; bip->num_normals = ntohl(*(uint32_t *)&cp[0]); cp += SIZEOF_NETWORK_LONG; @@ -1013,9 +1024,9 @@ bip->normals = (fastf_t *)bu_calloc(bip->num_normals * 3, sizeof(fastf_t), "BOT normals"); for (i = 0; i < bip->num_normals; i++) { - ntohd((unsigned char *)tmp, (const unsigned char *)cp, 3); - cp += SIZEOF_NETWORK_DOUBLE * 3; - MAT4X3VEC(&(bip->normals[i*3]), mat, tmp); + ntohd((unsigned char *)tmp, (const unsigned char *)cp, ELEMENTS_PER_VECT); + cp += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT; + MAT4X3VEC(&(bip->normals[i*ELEMENTS_PER_VECT]), mat, tmp); } } if (bip->num_face_normals > 0) { @@ -1103,12 +1114,13 @@ rem -= 3; for (i = 0; i < bip->num_vertices; i++) { - point_t tmp; + /* must be double for import and export */ + double tmp[ELEMENTS_PER_POINT]; - VSCALE(tmp, &bip->vertices[i*3], local2mm); - htond(cp, (unsigned char *)tmp, 3); - cp += SIZEOF_NETWORK_DOUBLE * 3; - rem -= SIZEOF_NETWORK_DOUBLE * 3; + VSCALE(tmp, &bip->vertices[i*ELEMENTS_PER_POINT], local2mm); + htond(cp, (unsigned char *)tmp, ELEMENTS_PER_POINT); + cp += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_POINT; + rem -= SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_POINT; } for (i = 0; i < bip->num_faces; i++) { @@ -1127,7 +1139,8 @@ if (bip->mode == RT_BOT_PLATE || bip->mode == RT_BOT_PLATE_NOCOS) { for (i = 0; i < bip->num_faces; i++) { - fastf_t tmp; + /* must be double for import and export */ + double tmp; tmp = bip->thickness[i] * local2mm; htond(cp, (const unsigned char *)&tmp, 1); @@ -1153,21 +1166,33 @@ rem -= SIZEOF_NETWORK_LONG; if (bip->num_normals > 0) { - htond(cp, (unsigned char*)bip->normals, bip->num_normals*3); - cp += SIZEOF_NETWORK_DOUBLE * 3 * bip->num_normals; - rem -= SIZEOF_NETWORK_DOUBLE * 3 * bip->num_normals; + /* must be double for import and export */ + double *normals; + normals = (double *)bu_malloc(bip->num_normals*ELEMENTS_PER_VECT*sizeof(double), "normals"); + + /* convert fastf_t to double */ + for (i=0; i < bip->num_normals * ELEMENTS_PER_VECT; i++) { + normals[i] = bip->normals[i]; + } + + htond(cp, (unsigned char*)normals, bip->num_normals*ELEMENTS_PER_VECT); + + bu_free(normals, "normals"); + + cp += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT * bip->num_normals; + rem -= SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT * bip->num_normals; } if (bip->num_face_normals > 0) { for (i = 0; i < bip->num_face_normals; i++) { - *(uint32_t *)&cp[0] = htonl(bip->face_normals[i*3 + 0]); + *(uint32_t *)&cp[0] = htonl(bip->face_normals[i*ELEMENTS_PER_VECT + 0]); cp += SIZEOF_NETWORK_LONG; rem -= SIZEOF_NETWORK_LONG; - *(uint32_t *)&cp[0] = htonl(bip->face_normals[i*3 + 1]); + *(uint32_t *)&cp[0] = htonl(bip->face_normals[i*ELEMENTS_PER_VECT + 1]); cp += SIZEOF_NETWORK_LONG; rem -= SIZEOF_NETWORK_LONG; - *(uint32_t *)&cp[0] = htonl(bip->face_normals[i*3 + 2]); + *(uint32_t *)&cp[0] = htonl(bip->face_normals[i*ELEMENTS_PER_VECT + 2]); cp += SIZEOF_NETWORK_LONG; rem -= SIZEOF_NETWORK_LONG; } @@ -1399,7 +1424,7 @@ botop->num_vertices = botip->num_vertices; botop->num_faces = botip->num_faces; if (botop->num_vertices > 0) { - botop->vertices = (fastf_t *)bu_malloc(botip->num_vertices * 3 * sizeof(fastf_t), "botop->vertices"); + botop->vertices = (fastf_t *)bu_malloc(botip->num_vertices * ELEMENTS_PER_POINT * sizeof(fastf_t), "botop->vertices"); } if (botop->num_faces > 0) { botop->faces = (int *)bu_malloc(botip->num_faces * 3 * sizeof(int), "botop->faces"); @@ -1435,8 +1460,8 @@ } for (i = 0; i < botip->num_vertices; i++) { - MAT4X3PNT(pt, mat, &botip->vertices[i*3]); - VMOVE(&botop->vertices[i*3], pt); + MAT4X3PNT(pt, mat, &botip->vertices[i*ELEMENTS_PER_POINT]); + VMOVE(&botop->vertices[i*ELEMENTS_PER_POINT], pt); } for (i = 0; i < botip->num_normals; i++) { @@ -1469,7 +1494,7 @@ fastf_t tmp_dist; fastf_t tmpx, tmpy; - MAT4X3PNT(v, mat, &bot->vertices[idx*3]) + MAT4X3PNT(v, mat, &bot->vertices[idx*ELEMENTS_PER_POINT]) tmpx = v[X] - pt2[X]; tmpy = v[Y] - pt2[Y]; tmp_dist = tmpx * tmpx + tmpy * tmpy; Modified: brlcad/trunk/src/librt/primitives/bspline/bspline.cpp =================================================================== --- brlcad/trunk/src/librt/primitives/bspline/bspline.cpp 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/bspline/bspline.cpp 2012-10-30 02:12:38 UTC (rev 53401) @@ -1054,8 +1054,14 @@ cp += SIZEOF_NETWORK_LONG; for (s = 0; s < sip->nsrf; s++) { - register struct face_g_snurb *srf = sip->srfs[s]; + int i; + struct face_g_snurb *srf = sip->srfs[s]; + /* must be double for import and export */ + double *uknots; + double *vknots; + double *points; + NMG_CK_SNURB(srf); coords = RT_NURB_EXTRACT_COORDS(srf->pt_type); @@ -1073,14 +1079,36 @@ cp += SIZEOF_NETWORK_LONG; *(uint32_t *)cp = htonl(srf->s_size[1]); cp += SIZEOF_NETWORK_LONG; - htond(cp, (unsigned char *)srf->u.knots, srf->u.k_size); + + /* alloate for export */ + uknots = (double *)bu_malloc(srf->u.k_size * sizeof(double), "uknots"); + vknots = (double *)bu_malloc(srf->v.k_size * sizeof(double), "vknots"); + points = (double *)bu_malloc(coords * srf->s_size[0] * srf->s_size[1] * sizeof(double), "points"); + + /* convert fastf_t to double */ + for (i=0; i<srf->u.k_size; i++) { + uknots[i] = srf->u.knots[i]; + } + for (i=0; i<srf->v.k_size; i++) { + vknots[i] = srf->v.knots[i]; + } + for (i=0; i<coords * srf->s_size[0] * srf->s_size[1]; i++) { + points[i] = srf->ctl_points[i]; + } + + /* serialize */ + htond(cp, (unsigned char *)uknots, srf->u.k_size); cp += srf->u.k_size * SIZEOF_NETWORK_DOUBLE; - htond(cp, (unsigned char *)srf->v.knots, srf->v.k_size); + htond(cp, (unsigned char *)vknots, srf->v.k_size); cp += srf->v.k_size * SIZEOF_NETWORK_DOUBLE; - htond(cp, (unsigned char *)srf->ctl_points, coords * srf->s_size[0] * srf->s_size[1]); cp += coords * srf->s_size[0] * srf->s_size[1] * SIZEOF_NETWORK_DOUBLE; + + /* release our arrays */ + bu_free(uknots, "uknots"); + bu_free(vknots, "vknots"); + bu_free(points, "points"); } bu_log("DEPRECATED: The 'bspline' primitive is no longer supported. Use 'brep' NURBS instead.\n"); @@ -1126,6 +1154,11 @@ int order[2], u_size, v_size; int s_size[2]; + /* must be double for import and export */ + double *uknots; + double *vknots; + double *points; + pt_type = ntohl(*(uint32_t *)cp); cp += SIZEOF_NETWORK_LONG; order[0] = ntohl(*(uint32_t *)cp); @@ -1154,17 +1187,39 @@ srf = sip->srfs[s]; coords = RT_NURB_EXTRACT_COORDS(srf->pt_type); - ntohd((unsigned char *)srf->u.knots, cp, srf->u.k_size); + uknots = (double *)bu_malloc(srf->u.k_size * sizeof(double), "uknots"); + vknots = (double *)bu_malloc(srf->v.k_size * sizeof(double), "vknots"); + + ntohd((unsigned char *)uknots, cp, srf->u.k_size); cp += srf->u.k_size * SIZEOF_NETWORK_DOUBLE; - ntohd((unsigned char *)srf->v.knots, cp, srf->v.k_size); + ntohd((unsigned char *)vknots, cp, srf->v.k_size); cp += srf->v.k_size * SIZEOF_NETWORK_DOUBLE; + /* convert double to fastf_t */ + for (i=0; i<srf->u.k_size; i++) { + srf->u.knots[i] = uknots[i]; + } + for (i=0; i<srf->v.k_size; i++) { + srf->v.knots[i] = vknots[i]; + } + + bu_free(uknots, "uknots"); + bu_free(vknots, "vknots"); + rt_nurb_kvnorm(&srf->u); rt_nurb_kvnorm(&srf->v); - ntohd((unsigned char *)srf->ctl_points, cp, - coords * srf->s_size[0] * srf->s_size[1]); + points = (double *)bu_malloc(coords * srf->s_size[0] * srf->s_size[1] * sizeof(double), "points"); + ntohd((unsigned char *)points, cp, coords * srf->s_size[0] * srf->s_size[1]); + + /* convert double to fastf_t */ + for (i=0; i < coords * srf->s_size[0] * srf->s_size[1]; i++) { + srf->ctl_points[i] = points[i]; + } + + bu_free(points, "points"); + cp += coords * srf->s_size[0] * srf->s_size[1] * SIZEOF_NETWORK_DOUBLE; if (mat == NULL) mat = bn_mat_identity; Modified: brlcad/trunk/src/librt/primitives/cline/cline.c =================================================================== --- brlcad/trunk/src/librt/primitives/cline/cline.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/cline/cline.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -830,8 +830,11 @@ { struct rt_cline_internal *cline_ip; union record *rp; - point_t work; + /* must be double for import and export */ + double work[ELEMENTS_PER_POINT]; + double scan; + BU_CK_EXTERNAL(ep); rp = (union record *)ep->ext_buf; /* Check record type */ @@ -852,13 +855,13 @@ cline_ip->magic = RT_CLINE_INTERNAL_MAGIC; if (mat == NULL) mat = bn_mat_identity; - ntohd((unsigned char *)(&cline_ip->thickness), rp->cli.cli_thick, 1); - cline_ip->thickness /= mat[15]; - ntohd((unsigned char *)(&cline_ip->radius), rp->cli.cli_radius, 1); - cline_ip->radius /= mat[15]; - ntohd((unsigned char *)(&work), rp->cli.cli_V, 3); + ntohd((unsigned char *)&scan, rp->cli.cli_thick, 1); + cline_ip->thickness = scan / mat[15]; + ntohd((unsigned char *)&scan, rp->cli.cli_radius, 1); + cline_ip->radius = scan / mat[15]; + ntohd((unsigned char *)&work, rp->cli.cli_V, ELEMENTS_PER_POINT); MAT4X3PNT(cline_ip->v, mat, work); - ntohd((unsigned char *)(&work), rp->cli.cli_h, 3); + ntohd((unsigned char *)&work, rp->cli.cli_h, ELEMENTS_PER_POINT); MAT4X3VEC(cline_ip->h, mat, work); return 0; /* OK */ @@ -875,9 +878,11 @@ { struct rt_cline_internal *cline_ip; union record *rec; - fastf_t tmp; - point_t work; + /* must be double for import and export */ + double tmp; + double work[ELEMENTS_PER_VECT]; + RT_CK_DB_INTERNAL(ip); if (ip->idb_type != ID_CLINE) return -1; cline_ip = (struct rt_cline_internal *)ip->idb_ptr; @@ -898,9 +903,9 @@ tmp = cline_ip->radius * local2mm; htond(rec->cli.cli_radius, (unsigned char *)(&tmp), 1); VSCALE(work, cline_ip->v, local2mm); - htond(rec->cli.cli_V, (unsigned char *)work, 3); + htond(rec->cli.cli_V, (unsigned char *)work, ELEMENTS_PER_VECT); VSCALE(work, cline_ip->h, local2mm); - htond(rec->cli.cli_h, (unsigned char *)work, 3); + htond(rec->cli.cli_h, (unsigned char *)work, ELEMENTS_PER_VECT); return 0; } @@ -916,8 +921,10 @@ rt_cline_import5(struct rt_db_internal *ip, const struct bu_external *ep, register const fastf_t *mat, const struct db_i *dbip) { struct rt_cline_internal *cline_ip; - fastf_t vec[8]; + /* must be double for import and export */ + double vec[8]; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -954,8 +961,10 @@ rt_cline_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_cline_internal *cline_ip; - fastf_t vec[8]; + /* must be double for import and export */ + double vec[8]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/dsp/dsp.c =================================================================== --- brlcad/trunk/src/librt/primitives/dsp/dsp.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/dsp/dsp.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -4391,6 +4391,9 @@ struct rt_dsp_internal *dsp_ip; unsigned char *cp; + /* must be double for import and export */ + double scanmat[16]; + if (resp) RT_CK_RESOURCE(resp); if (RT_G_DEBUG & DEBUG_HF) @@ -4437,8 +4440,10 @@ } /* convert matrix */ - ntohd((unsigned char *)dsp_ip->dsp_stom, cp, 16); - cp += SIZEOF_NETWORK_DOUBLE * 16; + ntohd((unsigned char *)scanmat, cp, ELEMENTS_PER_MAT); + MAT_COPY(dsp_ip->dsp_stom, scanmat); /* double to fastf_t */ + + cp += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_MAT; bn_mat_inv(dsp_ip->dsp_mtos, dsp_ip->dsp_stom); /* convert smooth flag */ @@ -4500,6 +4505,9 @@ unsigned char *cp; size_t rem; + /* must be double for import and export */ + double scanmat[16]; + if (resp) RT_CK_RESOURCE(resp); if (dbip) RT_CK_DBI(dbip); @@ -4545,10 +4553,12 @@ */ dsp_ip->dsp_stom[15] *= local2mm; - htond(cp, (unsigned char *)dsp_ip->dsp_stom, 16); - cp += SIZEOF_NETWORK_DOUBLE * 16; - rem -= SIZEOF_NETWORK_DOUBLE * 16; + MAT_COPY(scanmat, dsp_ip->dsp_stom); /* convert fastf_t to double */ + htond(cp, (unsigned char *)scanmat, ELEMENTS_PER_MAT); + cp += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_MAT; + rem -= SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_MAT; + *(uint16_t *)cp = htons((uint16_t)dsp_ip->dsp_smooth); cp += SIZEOF_NETWORK_SHORT; rem -= SIZEOF_NETWORK_SHORT; Modified: brlcad/trunk/src/librt/primitives/ehy/ehy.c =================================================================== --- brlcad/trunk/src/librt/primitives/ehy/ehy.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/ehy/ehy.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1752,8 +1752,10 @@ rt_ehy_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip) { struct rt_ehy_internal *xip; - fastf_t vec[3*4]; + /* must be double for import and export */ + double vec[3*4]; + BU_CK_EXTERNAL(ep); if (dbip) RT_CK_DBI(dbip); @@ -1800,8 +1802,10 @@ rt_ehy_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_ehy_internal *xip; - fastf_t vec[3*4]; + /* must be double for import and export */ + double vec[3*4]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/ell/ell.c =================================================================== --- brlcad/trunk/src/librt/primitives/ell/ell.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/ell/ell.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1369,8 +1369,10 @@ rt_ell_import5(struct rt_db_internal *ip, const struct bu_external *ep, register const fastf_t *mat, const struct db_i *dbip) { struct rt_ell_internal *eip; - fastf_t vec[ELEMENTS_PER_VECT*4]; + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT*4]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); BU_CK_EXTERNAL(ep); @@ -1412,8 +1414,10 @@ rt_ell_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_ell_internal *eip; - fastf_t vec[ELEMENTS_PER_VECT*4]; + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT*4]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/epa/epa.c =================================================================== --- brlcad/trunk/src/librt/primitives/epa/epa.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/epa/epa.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1722,8 +1722,10 @@ rt_epa_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip) { struct rt_epa_internal *xip; - fastf_t vec[11]; + /* must be double for import and export */ + double vec[11]; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -1769,9 +1771,11 @@ rt_epa_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_epa_internal *xip; - fastf_t vec[11]; fastf_t mag_h; + /* must be double for import and export */ + double vec[11]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/eto/eto.c =================================================================== --- brlcad/trunk/src/librt/primitives/eto/eto.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/eto/eto.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1406,8 +1406,10 @@ rt_eto_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip) { struct rt_eto_internal *tip; - fastf_t vec[11]; + /* must be double for import and export */ + double vec[11]; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -1450,8 +1452,10 @@ rt_eto_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_eto_internal *tip; - fastf_t vec[11]; + /* must be double for import and export */ + double vec[11]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/extrude/extrude.c =================================================================== --- brlcad/trunk/src/librt/primitives/extrude/extrude.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/extrude/extrude.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -2313,8 +2313,10 @@ char *sketch_name; union record *rp; char *ptr; - point_t tmp_vec; + /* must be double for import and export */ + double tmp_vec[ELEMENTS_PER_VECT]; + BU_CK_EXTERNAL(ep); rp = (union record *)ep->ext_buf; /* Check record type */ @@ -2378,7 +2380,10 @@ rt_extrude_export4(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_extrude_internal *extrude_ip; - vect_t tmp_vec; + + /* must be double for import and export */ + double tmp_vec[ELEMENTS_PER_VECT]; + union record *rec; unsigned char *ptr; @@ -2425,10 +2430,12 @@ rt_extrude_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_extrude_internal *extrude_ip; - vect_t tmp_vec[4]; unsigned char *ptr; size_t rem; + /* must be double for import and export */ + double tmp_vec[4][ELEMENTS_PER_VECT]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); @@ -2478,8 +2485,10 @@ struct directory *dp; char *sketch_name; unsigned char *ptr; - point_t tmp_vec[4]; + /* must be double for import and export */ + double tmp_vec[4][ELEMENTS_PER_VECT]; + BU_CK_EXTERNAL(ep); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/grip/grip.c =================================================================== --- brlcad/trunk/src/librt/primitives/grip/grip.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/grip/grip.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -368,9 +368,11 @@ rt_grp_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip) { struct rt_grip_internal *gip; - fastf_t vec[7]; double f, t; + /* must be double for import and export */ + double vec[7]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); BU_CK_EXTERNAL(ep); @@ -420,8 +422,10 @@ rt_grp_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_grip_internal *gip; - fastf_t vec[7]; + /* must be double for import and export */ + double vec[7]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/half/half.c =================================================================== --- brlcad/trunk/src/librt/primitives/half/half.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/half/half.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -657,16 +657,18 @@ int rt_hlf_import5(struct rt_db_internal *ip, const struct bu_external *ep, register const fastf_t *mat, const struct db_i *dbip) { + register double f, t; struct rt_half_internal *hip; point_t tmp_pt, new_pt; - plane_t tmp_plane; - register double f, t; + /* must be double for import and export */ + double tmp_plane[ELEMENTS_PER_PLANE]; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); - BU_ASSERT_LONG(ep->ext_nbytes, ==, SIZEOF_NETWORK_DOUBLE * 4); + BU_ASSERT_LONG(ep->ext_nbytes, ==, SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_PLANE); RT_CK_DB_INTERNAL(ip); ip->idb_major_type = DB5_MAJORTYPE_BRLCAD; @@ -678,7 +680,7 @@ hip->magic = RT_HALF_INTERNAL_MAGIC; /* Convert from database (network) to internal (host) format */ - ntohd((unsigned char *)tmp_plane, ep->ext_buf, 4); + ntohd((unsigned char *)tmp_plane, ep->ext_buf, ELEMENTS_PER_PLANE); /* to apply modeling transformations, create a temporary normal * vector and point on the plane @@ -718,8 +720,11 @@ rt_hlf_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_half_internal *hip; - fastf_t scaled_dist; + /* must be double for import and export */ + double scaled_dist; + double eqn[ELEMENTS_PER_VECT]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); @@ -735,10 +740,13 @@ scaled_dist = hip->eqn[W] * local2mm; /* Convert from internal (host) to database (network) format */ + /* the normal */ - htond((unsigned char *)ep->ext_buf, (unsigned char *)hip->eqn, 3); + VMOVE(eqn, hip->eqn); /* convert fastf_t to double */ + htond((unsigned char *)ep->ext_buf, (unsigned char *)eqn, ELEMENTS_PER_VECT); + /* the distance */ - htond(((unsigned char *)(ep->ext_buf)) + SIZEOF_NETWORK_DOUBLE*3, + htond(((unsigned char *)(ep->ext_buf)) + SIZEOF_NETWORK_DOUBLE*ELEMENTS_PER_VECT, (unsigned char *)&scaled_dist, 1); return 0; Modified: brlcad/trunk/src/librt/primitives/hyp/hyp.c =================================================================== --- brlcad/trunk/src/librt/primitives/hyp/hyp.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/hyp/hyp.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1195,8 +1195,10 @@ rt_hyp_import5(struct rt_db_internal *ip, const struct bu_external *ep, const mat_t mat, const struct db_i *dbip) { struct rt_hyp_internal *hyp_ip; - fastf_t vec[ELEMENTS_PER_VECT*4]; + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT*4]; + RT_CK_DB_INTERNAL(ip); BU_CK_EXTERNAL(ep); if (dbip) RT_CK_DBI(dbip); @@ -1224,7 +1226,7 @@ MAT4X3VEC(hyp_ip->hyp_A, mat, &vec[2*3]); if (!ZERO(mat[15])) - hyp_ip->hyp_b = vec[ 9] / mat[15]; + hyp_ip->hyp_b = vec[9] / mat[15]; else hyp_ip->hyp_b = INFINITY; hyp_ip->hyp_bnr = vec[10] ; @@ -1246,8 +1248,10 @@ rt_hyp_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_hyp_internal *hyp_ip; - fastf_t vec[ELEMENTS_PER_VECT * 4]; + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT * 4]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/metaball/metaball.c =================================================================== --- brlcad/trunk/src/librt/primitives/metaball/metaball.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/metaball/metaball.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -708,14 +708,16 @@ { struct wdb_metaballpt *mbpt; struct rt_metaball_internal *mb; - fastf_t *buf; int metaball_count = 0, i; + /* must be double for import and export */ + double *buf; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); metaball_count = ntohl(*(uint32_t *)ep->ext_buf); - buf = (fastf_t *)bu_malloc((metaball_count*5+1)*SIZEOF_NETWORK_DOUBLE, "rt_metaball_import5: buf"); + buf = (double *)bu_malloc((metaball_count*5+1)*SIZEOF_NETWORK_DOUBLE, "rt_metaball_import5: buf"); ntohd((unsigned char *)buf, (unsigned char *)ep->ext_buf+2*SIZEOF_NETWORK_LONG, metaball_count*5+1); RT_CK_DB_INTERNAL(ip); @@ -765,7 +767,8 @@ struct rt_metaball_internal *mb; struct wdb_metaballpt *mbpt; int metaball_count = 0, i = 1; - fastf_t *buf = NULL; + /* must be double for import and export */ + double *buf = NULL; if (dbip) RT_CK_DBI(dbip); @@ -788,7 +791,7 @@ *(uint32_t *)(ep->ext_buf + SIZEOF_NETWORK_LONG) = htonl(mb->method); /* pack the point data */ - buf = (fastf_t *)bu_malloc((metaball_count*5+1)*SIZEOF_NETWORK_DOUBLE, "rt_metaball_export5: buf"); + buf = (double *)bu_malloc((metaball_count*5+1)*SIZEOF_NETWORK_DOUBLE, "rt_metaball_export5: buf"); buf[0] = mb->threshold; for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head), i+=5) { VSCALE(&buf[i], mbpt->coord, local2mm); @@ -796,7 +799,7 @@ buf[i+4] = mbpt->sweat; } htond((unsigned char *)ep->ext_buf + 2*SIZEOF_NETWORK_LONG, (unsigned char *)buf, 1 + 5 * metaball_count); - bu_free((genptr_t)buf, "rt_metaball_export5: buf"); + bu_free(buf, "rt_metaball_export5: buf"); return 0; } Modified: brlcad/trunk/src/librt/primitives/nmg/nmg.c =================================================================== --- brlcad/trunk/src/librt/primitives/nmg/nmg.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/nmg/nmg.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -845,8 +845,12 @@ /* If zero, means literal array of values */ { + int i; unsigned char *cp; + /* always write doubles to disk */ + double *scanp; + if (pt_type) count *= RT_NURB_EXTRACT_COORDS(pt_type); @@ -854,28 +858,31 @@ *(uint32_t *)&cp[0] = htonl(DISK_DOUBLE_ARRAY_MAGIC); *(uint32_t *)&cp[4] = htonl(count); if (pt_type == 0 || ZERO(scale - 1.0)) { - htond(cp + (4+4), (unsigned char *)fp, count); + scanp = (double *)bu_malloc(count * sizeof(double), "scanp"); + /* convert fastf_t to double */ + for (i=0; i<count; i++) { + scanp[i] = fp[i]; + } + htond(cp + (4+4), (unsigned char *)scanp, count); + bu_free(scanp, "scanp"); } else { - fastf_t *newdata; - /* Need to scale data by 'scale' ! */ - newdata = (fastf_t *)bu_malloc(count*sizeof(fastf_t), "rt_nmg_export4_fastf"); + scanp = (double *)bu_malloc(count*sizeof(double), "scanp"); if (RT_NURB_IS_PT_RATIONAL(pt_type)) { /* Don't scale the homogeneous (rational) coord */ - int i; int nelem; /* # elements per tuple */ nelem = RT_NURB_EXTRACT_COORDS(pt_type); for (i = 0; i < count; i += nelem) { - VSCALEN(&newdata[i], &fp[i], scale, nelem-1); - newdata[i+nelem-1] = fp[i+nelem-1]; + VSCALEN(&scanp[i], &fp[i], scale, nelem-1); + scanp[i+nelem-1] = fp[i+nelem-1]; } } else { /* Scale everything as one long array */ - VSCALEN(newdata, fp, scale, count); + VSCALEN(scanp, fp, scale, count); } - htond(cp + (4+4), (unsigned char *)newdata, count); - bu_free((char *)newdata, "rt_nmg_export4_fastf"); + htond(cp + (4+4), (unsigned char *)scanp, count); + bu_free(scanp, "rt_nmg_export4_fastf"); } cp += (4+4) + count * 8; rt_nmg_fastf_p = cp; @@ -890,10 +897,15 @@ rt_nmg_import4_fastf(const unsigned char *base, struct nmg_exp_counts *ecnt, long int subscript, const matp_t mat, int len, int pt_type) { const unsigned char *cp; + + int i; int count; fastf_t *ret; - fastf_t *tmp; + /* must be double for import and export */ + double *tmp; + double *scanp; + if (ecnt[subscript].byte_offset <= 0 || ecnt[subscript].kind != NMG_KIND_DOUBLE_ARRAY) { bu_log("subscript=%d, byte_offset=%d, kind=%d (expected %d)\n", subscript, ecnt[subscript].byte_offset, @@ -922,7 +934,13 @@ } ret = (fastf_t *)bu_malloc(count * sizeof(fastf_t), "rt_nmg_import4_fastf[]"); if (!mat) { - ntohd((unsigned char *)ret, cp + (4+4), count); + scanp = (double *)bu_malloc(count * sizeof(double), "scanp"); + ntohd((unsigned char *)scanp, cp + (4+4), count); + /* read as double, return as fastf_t */ + for (i=0; i<count; i++) { + ret[i] = scanp[i]; + } + bu_free(scanp, "scanp"); return ret; } @@ -931,8 +949,9 @@ * Need to know width of data points, may be 3, or 4-tuples. * The vector times matrix calculation can't be done in place. */ - tmp = (fastf_t *)bu_malloc(count * sizeof(fastf_t), "rt_nmg_import4_fastf tmp[]"); + tmp = (double *)bu_malloc(count * sizeof(double), "rt_nmg_import4_fastf tmp[]"); ntohd((unsigned char *)tmp, cp + (4+4), count); + switch (RT_NURB_EXTRACT_COORDS(pt_type)) { case 3: if (RT_NURB_IS_PT_RATIONAL(pt_type)) bu_bomb("rt_nmg_import4_fastf() Rational 3-tuple?\n"); @@ -949,7 +968,9 @@ default: bu_bomb("rt_nmg_import4_fastf() unsupported # of coords in ctl_point\n"); } - bu_free((char *)tmp, "rt_nmg_import4_fastf tmp[]"); + + bu_free(tmp, "rt_nmg_import4_fastf tmp[]"); + return ret; } @@ -1054,14 +1075,18 @@ case NMG_KIND_NMGREGION_A: { struct nmgregion_a *r = (struct nmgregion_a *)ip; struct disk_nmgregion_a *d; - point_t min, max; + + /* must be double for import and export */ + double min[ELEMENTS_PER_POINT]; + double max[ELEMENTS_PER_POINT]; + d = &((struct disk_nmgregion_a *)op)[oindex]; NMG_CK_REGION_A(r); PUTMAGIC(DISK_REGION_A_MAGIC); VSCALE(min, r->min_pt, local2mm); VSCALE(max, r->max_pt, local2mm); - htond(d->min_pt, (unsigned char *)min, 3); - htond(d->max_pt, (unsigned char *)max, 3); + htond(d->min_pt, (unsigned char *)min, ELEMENTS_PER_POINT); + htond(d->max_pt, (unsigned char *)max, ELEMENTS_PER_POINT); } return; case NMG_KIND_SHELL: { @@ -1082,14 +1107,18 @@ case NMG_KIND_SHELL_A: { struct shell_a *sa = (struct shell_a *)ip; struct disk_shell_a *d; - point_t min, max; + + /* must be double for import and export */ + double min[ELEMENTS_PER_POINT]; + double max[ELEMENTS_PER_POINT]; + d = &((struct disk_shell_a *)op)[oindex]; NMG_CK_SHELL_A(sa); PUTMAGIC(DISK_SHELL_A_MAGIC); VSCALE(min, sa->min_pt, local2mm); VSCALE(max, sa->max_pt, local2mm); - htond(d->min_pt, (unsigned char *)min, 3); - htond(d->max_pt, (unsigned char *)max, 3); + htond(d->min_pt, (unsigned char *)min, ELEMENTS_PER_POINT); + htond(d->max_pt, (unsigned char *)max, ELEMENTS_PER_POINT); } return; case NMG_KIND_FACEUSE: { @@ -1124,14 +1153,20 @@ case NMG_KIND_FACE_G_PLANE: { struct face_g_plane *fg = (struct face_g_plane *)ip; struct disk_face_g_plane *d; - plane_t plane; + + /* must be double for import and export */ + double plane[ELEMENTS_PER_PLANE]; + d = &((struct disk_face_g_plane *)op)[oindex]; NMG_CK_FACE_G_PLANE(fg); PUTMAGIC(DISK_FACE_G_PLANE_MAGIC); INDEXL(d, fg, f_hd); + + /* convert fastf_t to double */ VMOVE(plane, fg->N); plane[W] = fg->N[W] * local2mm; - htond(d->N, (unsigned char *)plane, 4); + + htond(d->N, (unsigned char *)plane, ELEMENTS_PER_PLANE); } return; case NMG_KIND_FACE_G_SNURB: { @@ -1190,14 +1225,20 @@ case NMG_KIND_LOOP_G: { struct loop_g *lg = (struct loop_g *)ip; struct disk_loop_g *d; - point_t min, max; + + /* must be double for import and export */ + double min[ELEMENTS_PER_POINT]; + double max[ELEMENTS_PER_POINT]; + d = &((struct disk_loop_g *)op)[oindex]; NMG_CK_LOOP_G(lg); PUTMAGIC(DISK_LOOP_G_MAGIC); + VSCALE(min, lg->min_pt, local2mm); VSCALE(max, lg->max_pt, local2mm); - htond(d->min_pt, (unsigned char *)min, 3); - htond(d->max_pt, (unsigned char *)max, 3); + + htond(d->min_pt, (unsigned char *)min, ELEMENTS_PER_POINT); + htond(d->max_pt, (unsigned char *)max, ELEMENTS_PER_POINT); } return; case NMG_KIND_EDGEUSE: { @@ -1234,14 +1275,22 @@ case NMG_KIND_EDGE_G_LSEG: { struct edge_g_lseg *eg = (struct edge_g_lseg *)ip; struct disk_edge_g_lseg *d; - point_t pt; + + /* must be double for import and export */ + double pt[ELEMENTS_PER_POINT]; + double dir[ELEMENTS_PER_VECT]; + d = &((struct disk_edge_g_lseg *)op)[oindex]; NMG_CK_EDGE_G_LSEG(eg); PUTMAGIC(DISK_EDGE_G_LSEG_MAGIC); INDEXL(d, eg, eu_hd2); + + /* convert fastf_t to double */ VSCALE(pt, eg->e_pt, local2mm); - htond(d->e_pt, (unsigned char *)pt, 3); - htond(d->e_dir, (unsigned char *)eg->e_dir, 3); + VMOVE(dir, eg->e_dir); + + htond(d->e_pt, (unsigned char *)pt, ELEMENTS_PER_POINT); + htond(d->e_dir, (unsigned char *)dir, ELEMENTS_PER_VECT); } return; case NMG_KIND_EDGE_G_CNURB: { @@ -1291,23 +1340,35 @@ case NMG_KIND_VERTEXUSE_A_PLANE: { struct vertexuse_a_plane *vua = (struct vertexuse_a_plane *)ip; struct disk_vertexuse_a_plane *d; + + /* must be double for import and export */ + double normal[ELEMENTS_PER_VECT]; + d = &((struct disk_vertexuse_a_plane *)op)[oindex]; NMG_CK_VERTEXUSE_A_PLANE(vua); PUTMAGIC(DISK_VERTEXUSE_A_PLANE_MAGIC); + /* Normal vectors don't scale */ /* This is not a plane equation here */ - htond(d->N, (unsigned char *)vua->N, 3); + VMOVE(normal, vua->N); /* convert fastf_t to double */ + htond(d->N, (unsigned char *)normal, ELEMENTS_PER_VECT); } return; case NMG_KIND_VERTEXUSE_A_CNURB: { struct vertexuse_a_cnurb *vua = (struct vertexuse_a_cnurb *)ip; struct disk_vertexuse_a_cnurb *d; + /* must be double for import and export */ + double param[3]; + d = &((struct disk_vertexuse_a_cnurb *)op)[oindex]; NMG_CK_VERTEXUSE_A_CNURB(vua); PUTMAGIC(DISK_VERTEXUSE_A_CNURB_MAGIC); + /* (u, v) parameters on curves don't scale */ - htond(d->param, (unsigned char *)vua->param, 3); + VMOVE(param, vua->param); /* convert fastf_t to double */ + + htond(d->param, (unsigned char *)param, 3); } return; case NMG_KIND_VERTEX: { @@ -1323,12 +1384,16 @@ case NMG_KIND_VERTEX_G: { struct vertex_g *vg = (struct vertex_g *)ip; struct disk_vertex_g *d; - point_t pt; + + /* must be double for import and export */ + double pt[ELEMENTS_PER_POINT]; + d = &((struct disk_vertex_g *)op)[oindex]; NMG_CK_VERTEX_G(vg); PUTMAGIC(DISK_VERTEX_G_MAGIC); VSCALE(pt, vg->coord, local2mm); - htond(d->coord, (unsigned char *)pt, 3); + + htond(d->coord, (unsigned char *)pt, ELEMENTS_PER_POINT); } return; } @@ -1418,12 +1483,20 @@ case NMG_KIND_NMGREGION_A: { struct nmgregion_a *r = (struct nmgregion_a *)op; struct disk_nmgregion_a *d; - point_t min, max; + point_t min; + point_t max; + + /* must be double for import and export */ + double scanmin[ELEMENTS_PER_POINT]; + double scanmax[ELEMENTS_PER_POINT]; + d = &((struct disk_nmgregion_a *)ip)[iindex]; NMG_CK_REGION_A(r); NMG_CK_DISKMAGIC(d->magic, DISK_REGION_A_MAGIC); - ntohd((unsigned char *)min, d->min_pt, 3); - ntohd((unsigned char *)max, d->max_pt, 3); + ntohd((unsigned char *)scanmin, d->min_pt, ELEMENTS_PER_POINT); + VMOVE(min, scanmin); /* convert double to fastf_t */ + ntohd((unsigned char *)scanmax, d->max_pt, ELEMENTS_PER_POINT); + VMOVE(max, scanmax); /* convert double to fastf_t */ bn_rotate_bbox(r->min_pt, r->max_pt, mat, min, max); } return 0; @@ -1446,12 +1519,20 @@ case NMG_KIND_SHELL_A: { struct shell_a *sa = (struct shell_a *)op; struct disk_shell_a *d; - point_t min, max; + point_t min; + point_t max; + + /* must be double for import and export */ + double scanmin[ELEMENTS_PER_POINT]; + double scanmax[ELEMENTS_PER_POINT]; + d = &((struct disk_shell_a *)ip)[iindex]; NMG_CK_SHELL_A(sa); NMG_CK_DISKMAGIC(d->magic, DISK_SHELL_A_MAGIC); - ntohd((unsigned char *)min, d->min_pt, 3); - ntohd((unsigned char *)max, d->max_pt, 3); + ntohd((unsigned char *)scanmin, d->min_pt, ELEMENTS_PER_POINT); + VMOVE(min, scanmin); /* convert double to fastf_t */ + ntohd((unsigned char *)scanmax, d->max_pt, ELEMENTS_PER_POINT); + VMOVE(max, scanmax); /* convert double to fastf_t */ bn_rotate_bbox(sa->min_pt, sa->max_pt, mat, min, max); } return 0; @@ -1493,11 +1574,16 @@ struct face_g_plane *fg = (struct face_g_plane *)op; struct disk_face_g_plane *d; plane_t plane; + + /* must be double for import and export */ + double scan[ELEMENTS_PER_PLANE]; + d = &((struct disk_face_g_plane *)ip)[iindex]; NMG_CK_FACE_G_PLANE(fg); NMG_CK_DISKMAGIC(d->magic, DISK_FACE_G_PLANE_MAGIC); INDEXL_HD(d, fg, f_hd, fg->f_hd); - ntohd((unsigned char *)plane, d->N, 4); + ntohd((unsigned char *)scan, d->N, ELEMENTS_PER_PLANE); + HMOVE(plane, scan); /* convert double to fastf_t */ bn_rotate_plane(fg->N, mat, plane); } return 0; @@ -1568,12 +1654,20 @@ case NMG_KIND_LOOP_G: { struct loop_g *lg = (struct loop_g *)op; struct disk_loop_g *d; - point_t min, max; + point_t min; + point_t max; + + /* must be double for import and export */ + double scanmin[ELEMENTS_PER_POINT]; + double scanmax[ELEMENTS_PER_POINT]; + d = &((struct disk_loop_g *)ip)[iindex]; NMG_CK_LOOP_G(lg); NMG_CK_DISKMAGIC(d->magic, DISK_LOOP_G_MAGIC); - ntohd((unsigned char *)min, d->min_pt, 3); - ntohd((unsigned char *)max, d->max_pt, 3); + ntohd((unsigned char *)scanmin, d->min_pt, ELEMENTS_PER_POINT); + VMOVE(min, scanmin); /* convert double to fastf_t */ + ntohd((unsigned char *)scanmax, d->max_pt, ELEMENTS_PER_POINT); + VMOVE(max, scanmax); /* convert double to fastf_t */ bn_rotate_bbox(lg->min_pt, lg->max_pt, mat, min, max); } return 0; @@ -1633,13 +1727,19 @@ point_t pt; vect_t dir; + /* must be double for import and export */ + double scanpt[ELEMENTS_PER_POINT]; + double scandir[ELEMENTS_PER_VECT]; + d = &((struct disk_edge_g_lseg *)ip)[iindex]; NMG_CK_EDGE_G_LSEG(eg); NMG_CK_DISKMAGIC(d->magic, DISK_EDGE_G_LSEG_MAGIC); /* Forw subscript points to edgeuse, not edgeuse2 */ INDEXL_HD2(d, eg, eu_hd2, eg->eu_hd2); - ntohd((unsigned char *)pt, d->e_pt, 3); - ntohd((unsigned char *)dir, d->e_dir, 3); + ntohd((unsigned char *)scanpt, d->e_pt, ELEMENTS_PER_POINT); + VMOVE(pt, scanpt); /* convert double to fastf_t */ + ntohd((unsigned char *)scandir, d->e_dir, ELEMENTS_PER_VECT); + VMOVE(dir, scandir); /* convert double to fastf_t */ MAT4X3PNT(eg->e_pt, mat, pt); MAT4X3VEC(eg->e_dir, mat, dir); } @@ -1698,22 +1798,29 @@ case NMG_KIND_VERTEXUSE_A_PLANE: { struct vertexuse_a_plane *vua = (struct vertexuse_a_plane *)op; struct disk_vertexuse_a_plane *d; - vect_t norm; + /* must be double for import and export */ + double norm[ELEMENTS_PER_VECT]; + d = &((struct disk_vertexuse_a_plane *)ip)[iindex]; NMG_CK_VERTEXUSE_A_PLANE(vua); NMG_CK_DISKMAGIC(d->magic, DISK_VERTEXUSE_A_PLANE_MAGIC); - ntohd((unsigned char *)norm, d->N, 3); + ntohd((unsigned char *)norm, d->N, ELEMENTS_PER_VECT); MAT4X3VEC(vua->N, mat, norm); } return 0; case NMG_KIND_VERTEXUSE_A_CNURB: { struct vertexuse_a_cnurb *vua = (struct vertexuse_a_cnurb *)op; struct disk_vertexuse_a_cnurb *d; + + /* must be double for import and export */ + double scan[3]; + d = &((struct disk_vertexuse_a_cnurb *)ip)[iindex]; NMG_CK_VERTEXUSE_A_CNURB(vua); NMG_CK_DISKMAGIC(d->magic, DISK_VERTEXUSE_A_CNURB_MAGIC); /* These parameters are invariant w.r.t. 'mat' */ - ntohd((unsigned char *)vua->param, d->param, 3); + ntohd((unsigned char *)scan, d->param, 3); + VMOVE(vua->param, scan); /* convert double to fastf_t */ } return 0; case NMG_KIND_VERTEX: { @@ -1729,11 +1836,13 @@ case NMG_KIND_VERTEX_G: { struct vertex_g *vg = (struct vertex_g *)op; struct disk_vertex_g *d; - point_t pt; + /* must be double for import and export */ + double pt[ELEMENTS_PER_POINT]; + d = &((struct disk_vertex_g *)ip)[iindex]; NMG_CK_VERTEX_G(vg); NMG_CK_DISKMAGIC(d->magic, DISK_VERTEX_G_MAGIC); - ntohd((unsigned char *)pt, d->coord, 3); + ntohd((unsigned char *)pt, d->coord, ELEMENTS_PER_POINT); MAT4X3PNT(vg->coord, mat, pt); } return 0; Modified: brlcad/trunk/src/librt/primitives/part/part.c =================================================================== --- brlcad/trunk/src/librt/primitives/part/part.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/part/part.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1450,14 +1450,16 @@ int rt_part_import4(struct rt_db_internal *ip, const struct bu_external *ep, register const fastf_t *mat, const struct db_i *dbip) { - point_t v; - vect_t h; - double vrad; - double hrad; fastf_t maxrad, minrad; union record *rp; struct rt_part_internal *part; + /* must be double for import and export */ + double v[ELEMENTS_PER_POINT]; + double h[ELEMENTS_PER_VECT]; + double vrad; + double hrad; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -1469,8 +1471,8 @@ } /* Convert from database to internal format */ - ntohd((unsigned char *)v, rp->part.p_v, 3); - ntohd((unsigned char *)h, rp->part.p_h, 3); + ntohd((unsigned char *)v, rp->part.p_v, ELEMENTS_PER_POINT); + ntohd((unsigned char *)h, rp->part.p_h, ELEMENTS_PER_VECT); ntohd((unsigned char *)&vrad, rp->part.p_vrad, 1); ntohd((unsigned char *)&hrad, rp->part.p_hrad, 1); @@ -1541,11 +1543,13 @@ { struct rt_part_internal *pip; union record *rec; - point_t vert; - vect_t hi; - fastf_t vrad; - fastf_t hrad; + /* must be double for import and export */ + double vert[ELEMENTS_PER_POINT]; + double hi[ELEMENTS_PER_VECT]; + double vrad; + double hrad; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); @@ -1566,8 +1570,8 @@ /* pip->part_type is not converted -- internal only */ rec->part.p_id = DBID_PARTICLE; - htond(rec->part.p_v, (unsigned char *)vert, 3); - htond(rec->part.p_h, (unsigned char *)hi, 3); + htond(rec->part.p_v, (unsigned char *)vert, ELEMENTS_PER_POINT); + htond(rec->part.p_h, (unsigned char *)hi, ELEMENTS_PER_VECT); htond(rec->part.p_vrad, (unsigned char *)&vrad, 1); htond(rec->part.p_hrad, (unsigned char *)&hrad, 1); @@ -1583,8 +1587,10 @@ { fastf_t maxrad, minrad; struct rt_part_internal *part; - fastf_t vec[8]; + /* must be double for import and export */ + double vec[8]; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -1661,8 +1667,10 @@ rt_part_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_part_internal *pip; - fastf_t vec[8]; + /* must be double for import and export */ + double vec[8]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/pipe/pipe.c =================================================================== --- brlcad/trunk/src/librt/primitives/pipe/pipe.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/pipe/pipe.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -3351,6 +3351,9 @@ struct rt_pipe_internal *pip; union record *rp; + /* must be double for import and export */ + double scan[ELEMENTS_PER_VECT]; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -3378,11 +3381,18 @@ BU_LIST_INIT(&pip->pipe_segs_head); if (mat == NULL) mat = bn_mat_identity; for (exp_pipept = &rp->pwr.pwr_data[pip->pipe_count-1]; exp_pipept >= &rp->pwr.pwr_data[0]; exp_pipept--) { - ntohd((unsigned char *)&tmp.pp_id, exp_pipept->epp_id, 1); - ntohd((unsigned char *)&tmp.pp_od, exp_pipept->epp_od, 1); - ntohd((unsigned char *)&tmp.pp_bendradius, exp_pipept->epp_bendradius, 1); - ntohd((unsigned char *)tmp.pp_coord, exp_pipept->epp_coord, 3); + ntohd((unsigned char *)&scan[0], exp_pipept->epp_id, 1); + tmp.pp_id = scan[0]; /* convert double to fastf_t */ + ntohd((unsigned char *)&scan[1], exp_pipept->epp_od, 1); + tmp.pp_od = scan[1]; /* convert double to fastf_t */ + + ntohd((unsigned char *)&scan[2], exp_pipept->epp_bendradius, 1); + tmp.pp_bendradius = scan[2]; /* convert double to fastf_t */ + + ntohd((unsigned char *)scan, exp_pipept->epp_coord, ELEMENTS_PER_VECT); + VMOVE(tmp.pp_coord, scan); /* convert double to fastf_t */ + /* Apply modeling transformations */ BU_GET(ptp, struct wdb_pipept); ptp->l.magic = WDB_PIPESEG_MAGIC; @@ -3449,15 +3459,26 @@ /* Convert the pipe segments to external form */ epp = &rec->pwr.pwr_data[0]; for (BU_LIST_FOR(ppt, wdb_pipept, headp), epp++) { + double scan[ELEMENTS_PER_POINT]; + /* Convert from user units to mm */ VSCALE(tmp.pp_coord, ppt->pp_coord, local2mm); tmp.pp_id = ppt->pp_id * local2mm; tmp.pp_od = ppt->pp_od * local2mm; tmp.pp_bendradius = ppt->pp_bendradius * local2mm; - htond(epp->epp_coord, (unsigned char *)tmp.pp_coord, 3); - htond(epp->epp_id, (unsigned char *)&tmp.pp_id, 1); - htond(epp->epp_od, (unsigned char *)&tmp.pp_od, 1); - htond(epp->epp_bendradius, (unsigned char *)&tmp.pp_bendradius, 1); + + + VMOVE(scan, tmp.pp_coord); /* convert fastf_t to double */ + htond(epp->epp_coord, (unsigned char *)scan, ELEMENTS_PER_POINT); + + scan[0] = tmp.pp_id; /* convert fastf_t to double */ + htond(epp->epp_id, (unsigned char *)&scan[0], 1); + + scan[1] = tmp.pp_od; /* convert fastf_t to double */ + htond(epp->epp_od, (unsigned char *)&scan[1], 1); + + scan[2] = tmp.pp_bendradius; /* convert fastf_t to double */ + htond(epp->epp_bendradius, (unsigned char *)&scan[2], 1); } return 0; @@ -3472,7 +3493,10 @@ { struct wdb_pipept *ptp; struct rt_pipe_internal *pip; - fastf_t *vec; + + /* must be double for import and export */ + double *vec; + size_t total_count; int double_count; int byte_count; @@ -3498,7 +3522,8 @@ pip->pipe_magic = RT_PIPE_INTERNAL_MAGIC; pip->pipe_count = pipe_count; - vec = (fastf_t *)bu_malloc(byte_count, "rt_pipe_import5: vec"); + vec = (double *)bu_malloc(byte_count, "rt_pipe_import5: vec"); + /* Convert from database (network) to internal (host) format */ ntohd((unsigned char *)vec, (unsigned char *)ep->ext_buf + 4, double_count); @@ -3534,13 +3559,15 @@ struct rt_pipe_internal *pip; struct bu_list *headp; struct wdb_pipept *ppt; - fastf_t *vec; int total_count; int double_count; int byte_count; unsigned long pipe_count; int i = 0; + /* must be double for import and export */ + double *vec; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); @@ -3563,7 +3590,7 @@ double_count = pipe_count * 6; byte_count = double_count * SIZEOF_NETWORK_DOUBLE; total_count = 4 + byte_count; - vec = (fastf_t *)bu_malloc(byte_count, "rt_pipe_export5: vec"); + vec = (double *)bu_malloc(byte_count, "rt_pipe_export5: vec"); BU_CK_EXTERNAL(ep); ep->ext_nbytes = total_count; Modified: brlcad/trunk/src/librt/primitives/pnts/pnts.c =================================================================== --- brlcad/trunk/src/librt/primitives/pnts/pnts.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/pnts/pnts.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -113,6 +113,9 @@ unsigned long pointDataSize; unsigned char *buf = NULL; + /* must be double for import and export */ + double scan; + if (dbip) RT_CK_DBI(dbip); /* acquire internal pnts structure */ @@ -128,7 +131,8 @@ external->ext_buf = (genptr_t) bu_calloc(sizeof(unsigned char), external->ext_nbytes, "pnts external"); buf = (unsigned char *)external->ext_buf; - htond(buf, (unsigned char *)&pnts->scale, 1); + scan = pnts->scale; /* convert fastf_t to double */ + htond(buf, (unsigned char *)&scan, 1); buf += SIZEOF_NETWORK_DOUBLE; *(uint16_t *)buf = htons((unsigned short)pnts->type); buf += SIZEOF_NETWORK_SHORT; @@ -356,6 +360,9 @@ unsigned char *buf = NULL; unsigned long i; + /* must be double for import and export */ + double scan; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(internal); @@ -374,7 +381,8 @@ pnts->point = NULL; /* unpack the header */ - ntohd((unsigned char *)&pnts->scale, buf, 1); + ntohd((unsigned char *)&scan, buf, 1); + pnts->scale = scan; /* convert double to fastf_t */ buf += SIZEOF_NETWORK_DOUBLE; pnts->type = (rt_pnt_type)ntohs(*(uint16_t *)buf); buf += SIZEOF_NETWORK_SHORT; Modified: brlcad/trunk/src/librt/primitives/revolve/revolve.c =================================================================== --- brlcad/trunk/src/librt/primitives/revolve/revolve.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/revolve/revolve.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1467,8 +1467,10 @@ rt_revolve_import5(struct rt_db_internal *ip, const struct bu_external *ep, const mat_t mat, const struct db_i *dbip, struct resource *resp) { struct rt_revolve_internal *rip; - fastf_t vv[ELEMENTS_PER_VECT*3 + 1]; + /* must be double for import and export */ + double vv[ELEMENTS_PER_VECT*3 + 1]; + char *sketch_name; unsigned char *ptr; struct directory *dp; @@ -1613,7 +1615,10 @@ rt_revolve_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_revolve_internal *rip; - fastf_t vec[ELEMENTS_PER_VECT*3 + 1]; + + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT*3 + 1]; + unsigned char *ptr; if (dbip) RT_CK_DBI(dbip); Modified: brlcad/trunk/src/librt/primitives/rhc/rhc.c =================================================================== --- brlcad/trunk/src/librt/primitives/rhc/rhc.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/rhc/rhc.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1546,8 +1546,10 @@ rt_rhc_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip) { struct rt_rhc_internal *xip; - fastf_t vec[11]; + /* must be double for import and export */ + double vec[11]; + if (dbip) { RT_CK_DBI(dbip); } @@ -1597,8 +1599,10 @@ rt_rhc_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_rhc_internal *xip; - fastf_t vec[11]; + /* must be double for import and export */ + double vec[11]; + if (dbip) { RT_CK_DBI(dbip); } Modified: brlcad/trunk/src/librt/primitives/rpc/rpc.c =================================================================== --- brlcad/trunk/src/librt/primitives/rpc/rpc.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/rpc/rpc.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1412,8 +1412,10 @@ rt_rpc_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip) { struct rt_rpc_internal *xip; - fastf_t vec[10]; + /* must be double for import and export */ + double vec[10]; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -1457,9 +1459,11 @@ rt_rpc_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_rpc_internal *xip; - fastf_t vec[10]; fastf_t f, mag_b, mag_h; + /* must be double for import and export */ + double vec[10]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); Modified: brlcad/trunk/src/librt/primitives/sketch/sketch.c =================================================================== --- brlcad/trunk/src/librt/primitives/sketch/sketch.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/sketch/sketch.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -961,12 +961,15 @@ { struct rt_sketch_internal *sketch_ip; union record *rp; - vect_t v; size_t seg_no; unsigned char *ptr; struct rt_curve *crv; size_t i; + /* must be double for import and export */ + double v[ELEMENTS_PER_VECT]; + double *vp; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); @@ -991,22 +994,32 @@ sketch_ip->magic = RT_SKETCH_INTERNAL_MAGIC; if (mat == NULL) mat = bn_mat_identity; - ntohd((unsigned char *)v, rp->skt.skt_V, 3); + ntohd((unsigned char *)v, rp->skt.skt_V, ELEMENTS_PER_VECT); MAT4X3PNT(sketch_ip->V, mat, v); - ntohd((unsigned char *)v, rp->skt.skt_uvec, 3); + ntohd((unsigned char *)v, rp->skt.skt_uvec, ELEMENTS_PER_VECT); MAT4X3VEC(sketch_ip->u_vec, mat, v); - ntohd((unsigned char *)v, rp->skt.skt_vvec, 3); + ntohd((unsigned char *)v, rp->skt.skt_vvec, ELEMENTS_PER_VECT); MAT4X3VEC(sketch_ip->v_vec, mat, v); sketch_ip->vert_count = ntohl(*(uint32_t *)rp->skt.skt_vert_count); sketch_ip->curve.count = ntohl(*(uint32_t *)rp->skt.skt_count); ptr = (unsigned char *)rp; ptr += sizeof(struct sketch_rec); - if (sketch_ip->vert_count) + if (sketch_ip->vert_count) { sketch_ip->verts = (point2d_t *)bu_calloc(sketch_ip->vert_count, sizeof(point2d_t), "sketch_ip->vert"); - ntohd((unsigned char *)sketch_ip->verts, ptr, sketch_ip->vert_count*2); - ptr += 16 * sketch_ip->vert_count; + vp = (double *)bu_calloc(sketch_ip->vert_count, sizeof(double)*ELEMENTS_PER_VECT2D, "vp"); + ntohd((unsigned char *)vp, ptr, sketch_ip->vert_count*ELEMENTS_PER_VECT2D); + /* convert double to fastf_t */ + for (i=0; i<sketch_ip->vert_count; i++) { + sketch_ip->verts[i][X] = vp[(i*ELEMENTS_PER_VECT2D)+0]; + sketch_ip->verts[i][Y] = vp[(i*ELEMENTS_PER_VECT2D)+1]; + } + + bu_free(vp, "vp"); + ptr += 16 * sketch_ip->vert_count; + } + if (sketch_ip->curve.count) sketch_ip->curve.segment = (genptr_t *)bu_calloc(sketch_ip->curve.count, sizeof(genptr_t), "segs"); else @@ -1018,6 +1031,10 @@ struct nurb_seg *nsg; struct bezier_seg *bsg; + /* must be double for import and export */ + double scan; + double *scanp; + magic = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; switch (magic) { @@ -1041,7 +1058,8 @@ ptr += SIZEOF_NETWORK_LONG; csg->center_is_left = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; - ntohd((unsigned char *)&csg->radius, ptr, 1); + ntohd((unsigned char *)&scan, ptr, 1); + csg->radius = scan; /* convert double to fastf_t */ ptr += SIZEOF_NETWORK_DOUBLE; sketch_ip->curve.segment[seg_no] = (genptr_t)csg; break; @@ -1054,8 +1072,17 @@ ptr += SIZEOF_NETWORK_LONG; nsg->k.k_size = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; + nsg->k.knots = (fastf_t *)bu_malloc(nsg->k.k_size * sizeof(fastf_t), "nsg->k.knots"); - ntohd((unsigned char *)nsg->k.knots, ptr, nsg->k.k_size); + scanp = (double *)bu_malloc(nsg->k.k_size * sizeof(double), "scanp"); + ntohd((unsigned char *)scanp, ptr, nsg->k.k_size); + + /* convert double to fastf_t */ + for (i=0; i<(size_t)nsg->k.k_size; i++) { + nsg->k.knots[i] = scanp[i]; + } + bu_free(scanp, "scanp"); + ptr += SIZEOF_NETWORK_DOUBLE * nsg->k.k_size; nsg->c_size = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; @@ -1066,10 +1093,19 @@ } if (RT_NURB_IS_PT_RATIONAL(nsg->pt_type)) { nsg->weights = (fastf_t *)bu_malloc(nsg->c_size * sizeof(fastf_t), "nsg->weights"); - ntohd((unsigned char *)nsg->weights, ptr, nsg->c_size); + scanp = (double *)bu_malloc(nsg->c_size * sizeof(double), "scanp"); + ntohd((unsigned char *)scanp, ptr, nsg->c_size); + + /* convert double to fastf_t */ + for (i=0; i<(size_t)nsg->k.k_size; i++) { + nsg->weights[i] = scanp[i]; + } + bu_free(scanp, "scanp"); + ptr += SIZEOF_NETWORK_DOUBLE * nsg->c_size; - } else + } else { nsg->weights = (fastf_t *)NULL; + } sketch_ip->curve.segment[seg_no] = (genptr_t)nsg; break; case CURVE_BEZIER_MAGIC: @@ -1119,9 +1155,11 @@ struct rt_sketch_internal *sketch_ip; union record *rec; size_t i, seg_no, nbytes=0, ngran; - vect_t tmp_vec; unsigned char *ptr; + /* must be double for import and export */ + double tmp_vec[ELEMENTS_PER_VECT]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); @@ -1180,11 +1218,13 @@ * to database record format */ VSCALE(tmp_vec, sketch_ip->V, local2mm); - htond(rec->skt.skt_V, (unsigned char *)tmp_vec, 3); + htond(rec->skt.skt_V, (unsigned char *)tmp_vec, ELEMENTS_PER_VECT); /* uvec and uvec are unit vectors, do not convert to/from mm */ - htond(rec->skt.skt_uvec, (unsigned char *)sketch_ip->u_vec, 3); - htond(rec->skt.skt_vvec, (unsigned char *)sketch_ip->v_vec, 3); + VMOVE(tmp_vec, sketch_ip->u_vec); /* convert fastf_t to double */ + htond(rec->skt.skt_uvec, (unsigned char *)tmp_vec, ELEMENTS_PER_VECT); + VMOVE(tmp_vec, sketch_ip->v_vec); /* convert fastf_t to double */ + htond(rec->skt.skt_vvec, (unsigned char *)tmp_vec, ELEMENTS_PER_VECT); *(uint32_t *)rec->skt.skt_vert_count = htonl(sketch_ip->vert_count); *(uint32_t *)rec->skt.skt_count = htonl(sketch_ip->curve.count); @@ -1194,10 +1234,11 @@ ptr += sizeof(struct sketch_rec); /* convert 2D points to mm */ for (i=0; i<sketch_ip->vert_count; i++) { - point2d_t pt2d; + /* must be double for import and export */ + double pt2d[ELEMENTS_PER_VECT2D]; - V2SCALE(pt2d, sketch_ip->verts[i], local2mm) - htond(ptr, (const unsigned char *)pt2d, 2); + V2SCALE(pt2d, sketch_ip->verts[i], local2mm); + htond(ptr, (const unsigned char *)pt2d, ELEMENTS_PER_VECT2D); ptr += 16; } @@ -1207,8 +1248,11 @@ struct nurb_seg *nseg; struct bezier_seg *bseg; uint32_t *lng; - fastf_t tmp_fastf; + /* must be double for import and export */ + double tmp_fastf; + double *scanp; + /* write segment type ID, and segment parameters */ lng = (uint32_t *)sketch_ip->curve.segment[seg_no]; switch (*lng) { @@ -1247,7 +1291,13 @@ ptr += SIZEOF_NETWORK_LONG; *(uint32_t *)ptr = htonl(nseg->k.k_size); ptr += SIZEOF_NETWORK_LONG; - htond(ptr, (const unsigned char *)nseg->k.knots, nseg->k.k_size); + scanp = (double *)bu_malloc(nseg->k.k_size * sizeof(double), "scanp"); + /* convert fastf_t to double */ + for (i=0; i<(size_t)nseg->k.k_size; i++) { + scanp[i] = nseg->k.knots[i]; + } + htond(ptr, (const unsigned char *)scanp, nseg->k.k_size); + bu_free(scanp, "scanp"); ptr += nseg->k.k_size * 8; *(uint32_t *)ptr = htonl(nseg->c_size); ptr += SIZEOF_NETWORK_LONG; @@ -1256,7 +1306,13 @@ ptr += SIZEOF_NETWORK_LONG; } if (RT_NURB_IS_PT_RATIONAL(nseg->pt_type)) { - htond(ptr, (const unsigned char *)nseg->weights, nseg->c_size); + scanp = (double *)bu_malloc(nseg->c_size * sizeof(double), "scanp"); + /* convert fastf_t to double */ + for (i=0; i<(size_t)nseg->c_size; i++) { + scanp[i] = nseg->weights[i]; + } + htond(ptr, (const unsigned char *)scanp, nseg->c_size); + bu_free(scanp, "scanp"); ptr += SIZEOF_NETWORK_DOUBLE * nseg->c_size; } break; @@ -1301,12 +1357,15 @@ rt_sketch_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip) { struct rt_sketch_internal *sketch_ip; - vect_t v; size_t seg_no; unsigned char *ptr; struct rt_curve *crv; size_t i; + /* must be double for import and export */ + double v[ELEMENTS_PER_VECT]; + double *vp; + if (bu_debug&BU_DEBUG_MEM_CHECK) { bu_log("Barrier check at start of sketch_import5():\n"); bu_mem_barriercheck(); @@ -1325,25 +1384,35 @@ ptr = ep->ext_buf; if (mat == NULL) mat = bn_mat_identity; - ntohd((unsigned char *)v, ptr, 3); + ntohd((unsigned char *)v, ptr, ELEMENTS_PER_VECT); MAT4X3PNT(sketch_ip->V, mat, v); - ptr += SIZEOF_NETWORK_DOUBLE * 3; - ntohd((unsigned char *)v, ptr, 3); + ptr += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT; + ntohd((unsigned char *)v, ptr, ELEMENTS_PER_VECT); MAT4X3VEC(sketch_ip->u_vec, mat, v); - ptr += SIZEOF_NETWORK_DOUBLE * 3; - ntohd((unsigned char *)v, ptr, 3); + ptr += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT; + ntohd((unsigned char *)v, ptr, ELEMENTS_PER_VECT); MAT4X3VEC(sketch_ip->v_vec, mat, v); - ptr += SIZEOF_NETWORK_DOUBLE * 3; + ptr += SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT; sketch_ip->vert_count = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; sketch_ip->curve.count = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; - if (sketch_ip->vert_count) + if (sketch_ip->vert_count) { sketch_ip->verts = (point2d_t *)bu_calloc(sketch_ip->vert_count, sizeof(point2d_t), "sketch_ip->vert"); - ntohd((unsigned char *)sketch_ip->verts, ptr, sketch_ip->vert_count*2); - ptr += SIZEOF_NETWORK_DOUBLE * 2 * sketch_ip->vert_count; + vp = (double *)bu_calloc(sketch_ip->vert_count, sizeof(double)*ELEMENTS_PER_VECT2D, "vp"); + ntohd((unsigned char *)vp, ptr, sketch_ip->vert_count*2); + /* convert double to fastf_t */ + for (i=0; i<sketch_ip->vert_count; i++) { + sketch_ip->verts[i][X] = vp[(i*ELEMENTS_PER_VECT2D)+0]; + sketch_ip->verts[i][Y] = vp[(i*ELEMENTS_PER_VECT2D)+1]; + } + + bu_free(vp, "vp"); + ptr += SIZEOF_NETWORK_DOUBLE * 2 * sketch_ip->vert_count; + } + if (sketch_ip->curve.count) sketch_ip->curve.segment = (genptr_t *)bu_calloc(sketch_ip->curve.count, sizeof(genptr_t), "segs"); else @@ -1355,6 +1424,10 @@ struct nurb_seg *nsg; struct bezier_seg *bsg; + /* must be double for import and export */ + double scan; + double *scanp; + magic = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; switch (magic) { @@ -1378,7 +1451,8 @@ ptr += SIZEOF_NETWORK_LONG; csg->center_is_left = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; - ntohd((unsigned char *)&csg->radius, ptr, 1); + ntohd((unsigned char *)&scan, ptr, 1); + csg->radius = scan; /* double to fastf_t */ ptr += SIZEOF_NETWORK_DOUBLE; sketch_ip->curve.segment[seg_no] = (genptr_t)csg; break; @@ -1391,8 +1465,17 @@ ptr += SIZEOF_NETWORK_LONG; nsg->k.k_size = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; + nsg->k.knots = (fastf_t *)bu_malloc(nsg->k.k_size * sizeof(fastf_t), "nsg->k.knots"); - ntohd((unsigned char *)nsg->k.knots, ptr, nsg->k.k_size); + scanp = (double *)bu_malloc(nsg->k.k_size * sizeof(double), "scanp"); + ntohd((unsigned char *)scanp, ptr, nsg->k.k_size); + + /* convert double to fastf_t */ + for (i=0; i<(size_t)nsg->k.k_size; i++) { + nsg->k.knots[i] = scanp[i]; + } + bu_free(scanp, "scanp"); + ptr += SIZEOF_NETWORK_DOUBLE * nsg->k.k_size; nsg->c_size = ntohl(*(uint32_t *)ptr); ptr += SIZEOF_NETWORK_LONG; @@ -1403,7 +1486,15 @@ } if (RT_NURB_IS_PT_RATIONAL(nsg->pt_type)) { nsg->weights = (fastf_t *)bu_malloc(nsg->c_size * sizeof(fastf_t), "nsg->weights"); - ntohd((unsigned char *)nsg->weights, ptr, nsg->c_size); + scanp = (double *)bu_malloc(nsg->c_size * sizeof(double), "scanp"); + ntohd((unsigned char *)scanp, ptr, nsg->c_size); + + /* convert double to fastf_t */ + for (i=0; i<(size_t)nsg->k.k_size; i++) { + nsg->weights[i] = scanp[i]; + } + bu_free(scanp, "scanp"); + ptr += SIZEOF_NETWORK_DOUBLE * nsg->c_size; } else nsg->weights = (fastf_t *)NULL; @@ -1459,8 +1550,10 @@ unsigned char *cp; size_t seg_no; size_t i; - vect_t tmp_vec; + /* must be double for import and export */ + double tmp_vec[ELEMENTS_PER_VECT]; + if (bu_debug&BU_DEBUG_MEM_CHECK) { bu_log("Barrier check at start of sketch_export5():\n"); bu_mem_barriercheck(); @@ -1476,7 +1569,7 @@ BU_CK_EXTERNAL(ep); /* tally up size of buffer needed */ - ep->ext_nbytes = 3 * (3 * SIZEOF_NETWORK_DOUBLE) /* V, u_vec, v_vec */ + ep->ext_nbytes = 3 * (ELEMENTS_PER_VECT * SIZEOF_NETWORK_DOUBLE) /* V, u_vec, v_vec */ + 2 * SIZEOF_NETWORK_LONG /* vert_count and count */ + 2 * sketch_ip->vert_count * SIZEOF_NETWORK_DOUBLE /* 2D-vertices */ + sketch_ip->curve.count * SIZEOF_NETWORK_LONG; /* reverse flags */ @@ -1526,14 +1619,16 @@ /* scale and export */ VSCALE(tmp_vec, sketch_ip->V, local2mm); - htond(cp, (unsigned char *)tmp_vec, 3); - cp += 3 * SIZEOF_NETWORK_DOUBLE; + htond(cp, (unsigned char *)tmp_vec, ELEMENTS_PER_VECT); + cp += ELEMENTS_PER_VECT * SIZEOF_NETWORK_DOUBLE; /* uvec and uvec are unit vectors, do not convert to/from mm */ - htond(cp, (unsigned char *)sketch_ip->u_vec, 3); - cp += 3 * SIZEOF_NETWORK_DOUBLE; - htond(cp, (unsigned char *)sketch_ip->v_vec, 3); - cp += 3 * SIZEOF_NETWORK_DOUBLE; + VMOVE(tmp_vec, sketch_ip->u_vec); /* convert fastf_t to double */ + htond(cp, (unsigned char *)tmp_vec, ELEMENTS_PER_VECT); + cp += ELEMENTS_PER_VECT * SIZEOF_NETWORK_DOUBLE; + VMOVE(tmp_vec, sketch_ip->v_vec); /* convert fastf_t to double */ + htond(cp, (unsigned char *)tmp_vec, ELEMENTS_PER_VECT); + cp += ELEMENTS_PER_VECT * SIZEOF_NETWORK_DOUBLE; *(uint32_t *)cp = htonl(sketch_ip->vert_count); cp += SIZEOF_NETWORK_LONG; @@ -1542,10 +1637,11 @@ /* convert 2D points to mm */ for (i=0; i<sketch_ip->vert_count; i++) { - point2d_t pt2d; + /* must be double for import and export */ + double pt2d[ELEMENTS_PER_VECT2D]; - V2SCALE(pt2d, sketch_ip->verts[i], local2mm) - htond(cp, (const unsigned char *)pt2d, 2); + V2SCALE(pt2d, sketch_ip->verts[i], local2mm); + htond(cp, (const unsigned char *)pt2d, ELEMENTS_PER_VECT2D); cp += 2 * SIZEOF_NETWORK_DOUBLE; } @@ -1555,8 +1651,11 @@ struct nurb_seg *nseg; struct bezier_seg *bseg; uint32_t *lng; - fastf_t tmp_fastf; + /* must be double for import and export */ + double scan; + double *scanp; + /* write segment type ID, and segment parameters */ lng = (uint32_t *)sketch_ip->curve.segment[seg_no]; switch (*lng) { @@ -1581,8 +1680,8 @@ cp += SIZEOF_NETWORK_LONG; *(uint32_t *)cp = htonl(cseg->center_is_left); cp += SIZEOF_NETWORK_LONG; - tmp_fastf = cseg->radius * local2mm; - htond(cp, (unsigned char *)&tmp_fastf, 1); + scan = cseg->radius * local2mm; + htond(cp, (unsigned char *)&scan, 1); cp += SIZEOF_NETWORK_DOUBLE; break; case CURVE_NURB_MAGIC: @@ -1595,7 +1694,13 @@ cp += SIZEOF_NETWORK_LONG; *(uint32_t *)cp = htonl(nseg->k.k_size); cp += SIZEOF_NETWORK_LONG; + scanp = (double *)bu_malloc(nseg->k.k_size * sizeof(double), "scanp"); + /* convert fastf_t to double */ + for (i=0; i<(size_t)nseg->k.k_size; i++) { + scanp[i] = nseg->k.knots[i]; + } htond(cp, (const unsigned char *)nseg->k.knots, nseg->k.k_size); + bu_free(scanp, "scanp"); cp += nseg->k.k_size * SIZEOF_NETWORK_DOUBLE; *(uint32_t *)cp = htonl(nseg->c_size); cp += SIZEOF_NETWORK_LONG; @@ -1604,7 +1709,13 @@ cp += SIZEOF_NETWORK_LONG; } if (RT_NURB_IS_PT_RATIONAL(nseg->pt_type)) { - htond(cp, (const unsigned char *)nseg->weights, nseg->c_size); + scanp = (double *)bu_malloc(nseg->c_size * sizeof(double), "scanp"); + /* convert fastf_t to double */ + for (i=0; i<(size_t)nseg->c_size; i++) { + scanp[i] = nseg->weights[i]; + } + htond(cp, (const unsigned char *)scanp, nseg->c_size); + bu_free(scanp, "scanp"); cp += SIZEOF_NETWORK_DOUBLE * nseg->c_size; } break; Modified: brlcad/trunk/src/librt/primitives/tgc/tgc.c =================================================================== --- brlcad/trunk/src/librt/primitives/tgc/tgc.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/tgc/tgc.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1635,12 +1635,14 @@ rt_tgc_import5(struct rt_db_internal *ip, const struct bu_external *ep, register const fastf_t *mat, const struct db_i *dbip) { struct rt_tgc_internal *tip; - fastf_t vec[3*6]; + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT*6]; + if (dbip) RT_CK_DBI(dbip); BU_CK_EXTERNAL(ep); - BU_ASSERT_LONG(ep->ext_nbytes, ==, SIZEOF_NETWORK_DOUBLE * 3*6); + BU_ASSERT_LONG(ep->ext_nbytes, ==, SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT*6); RT_CK_DB_INTERNAL(ip); ip->idb_major_type = DB5_MAJORTYPE_BRLCAD; @@ -1652,16 +1654,16 @@ tip->magic = RT_TGC_INTERNAL_MAGIC; /* Convert from database (network) to internal (host) format */ - ntohd((unsigned char *)vec, ep->ext_buf, 3*6); + ntohd((unsigned char *)vec, ep->ext_buf, ELEMENTS_PER_VECT*6); /* Apply modeling transformations */ if (mat == NULL) mat = bn_mat_identity; - MAT4X3PNT(tip->v, mat, &vec[0*3]); - MAT4X3VEC(tip->h, mat, &vec[1*3]); - MAT4X3VEC(tip->a, mat, &vec[2*3]); - MAT4X3VEC(tip->b, mat, &vec[3*3]); - MAT4X3VEC(tip->c, mat, &vec[4*3]); - MAT4X3VEC(tip->d, mat, &vec[5*3]); + MAT4X3PNT(tip->v, mat, &vec[0*ELEMENTS_PER_VECT]); + MAT4X3VEC(tip->h, mat, &vec[1*ELEMENTS_PER_VECT]); + MAT4X3VEC(tip->a, mat, &vec[2*ELEMENTS_PER_VECT]); + MAT4X3VEC(tip->b, mat, &vec[3*ELEMENTS_PER_VECT]); + MAT4X3VEC(tip->c, mat, &vec[4*ELEMENTS_PER_VECT]); + MAT4X3VEC(tip->d, mat, &vec[5*ELEMENTS_PER_VECT]); return 0; /* OK */ } @@ -1674,8 +1676,10 @@ rt_tgc_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_tgc_internal *tip; - fastf_t vec[3*6]; + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT*6]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); @@ -1684,19 +1688,19 @@ RT_TGC_CK_MAGIC(tip); BU_CK_EXTERNAL(ep); - ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE * 3*6; + ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT*6; ep->ext_buf = (genptr_t)bu_malloc(ep->ext_nbytes, "tgc external"); /* scale 'em into local buffer */ - VSCALE(&vec[0*3], tip->v, local2mm); - VSCALE(&vec[1*3], tip->h, local2mm); - VSCALE(&vec[2*3], tip->a, local2mm); - VSCALE(&vec[3*3], tip->b, local2mm); - VSCALE(&vec[4*3], tip->c, local2mm); - VSCALE(&vec[5*3], tip->d, local2mm); + VSCALE(&vec[0*ELEMENTS_PER_VECT], tip->v, local2mm); + VSCALE(&vec[1*ELEMENTS_PER_VECT], tip->h, local2mm); + VSCALE(&vec[2*ELEMENTS_PER_VECT], tip->a, local2mm); + VSCALE(&vec[3*ELEMENTS_PER_VECT], tip->b, local2mm); + VSCALE(&vec[4*ELEMENTS_PER_VECT], tip->c, local2mm); + VSCALE(&vec[5*ELEMENTS_PER_VECT], tip->d, local2mm); /* Convert from internal (host) to database (network) format */ - htond(ep->ext_buf, (unsigned char *)vec, 3*6); + htond(ep->ext_buf, (unsigned char *)vec, ELEMENTS_PER_VECT*6); return 0; } @@ -1895,8 +1899,8 @@ { struct rt_tgc_internal *tip; register int i; - fastf_t top[16*3]; - fastf_t bottom[16*3]; + fastf_t top[16*ELEMENTS_PER_VECT]; + fastf_t bottom[16*ELEMENTS_PER_VECT]; vect_t work; /* Vec addition work area */ BU_CK_LIST_HEAD(vhead); Modified: brlcad/trunk/src/librt/primitives/tor/tor.c =================================================================== --- brlcad/trunk/src/librt/primitives/tor/tor.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/tor/tor.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -1455,9 +1455,11 @@ int rt_tor_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { - double vec[2*3+2]; struct rt_tor_internal *tip; + /* must be double for export */ + double vec[2*3+2]; + if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); @@ -1588,6 +1590,8 @@ rt_tor_import5(struct rt_db_internal *ip, const struct bu_external *ep, register const fastf_t *mat, const struct db_i *dbip) { struct rt_tor_internal *tip; + + /* must be double for import and export */ struct rec { double v[3]; double h[3]; @@ -1629,7 +1633,7 @@ tip->r_b = tip->r_a; /* Calculate two mutually perpendicular vectors, perpendicular to N */ - bn_vec_ortho(tip->a, tip->h); /* a has unit length */ + bn_vec_ortho(tip->a, tip->h); /* a has unit length */ VCROSS(tip->b, tip->h, tip->a); /* |A| = |H| = 1, so |B|=1 */ VSCALE(tip->a, tip->a, tip->r_a); Modified: brlcad/trunk/src/librt/primitives/xxx/xxx.c =================================================================== --- brlcad/trunk/src/librt/primitives/xxx/xxx.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/primitives/xxx/xxx.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -295,8 +295,10 @@ rt_xxx_import5(struct rt_db_internal *ip, const struct bu_external *ep, const mat_t mat, const struct db_i *dbip) { struct rt_xxx_internal *xxx_ip; - fastf_t vv[ELEMENTS_PER_VECT*1]; + /* must be double for import and export */ + double vv[ELEMENTS_PER_VECT*1]; + RT_CK_DB_INTERNAL(ip); BU_CK_EXTERNAL(ep); if (dbip) RT_CK_DBI(dbip); @@ -338,8 +340,10 @@ rt_xxx_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_xxx_internal *xxx_ip; - fastf_t vec[ELEMENTS_PER_VECT]; + /* must be double for import and export */ + double vec[ELEMENTS_PER_VECT]; + RT_CK_DB_INTERNAL(ip); if (ip->idb_type != ID_XXX) return -1; xxx_ip = (struct rt_xxx_internal *)ip->idb_ptr; @@ -358,7 +362,7 @@ VSCALE(vec, xxx_ip->v, local2mm); /* Convert from internal (host) to database (network) format */ - htond(ep->ext_buf, (unsigned char *)vec, ELEMENTS_PER_VECT*1); + htond(ep->ext_buf, (unsigned char *)vec, ELEMENTS_PER_VECT); return 0; } Modified: brlcad/trunk/src/librt/vlist.c =================================================================== --- brlcad/trunk/src/librt/vlist.c 2012-10-30 01:52:12 UTC (rev 53400) +++ brlcad/trunk/src/librt/vlist.c 2012-10-30 02:12:38 UTC (rev 53401) @@ -385,7 +385,7 @@ * nelem[4], String[n+1], cmds[nelem*1], pts[3*nelem*8] */ namelen = strlen(name)+1; - nbytes = namelen + 4 + nelem * (1+3*8) + 2; + nbytes = namelen + 4 + nelem * (1+ELEMENTS_PER_VECT*SIZEOF_NETWORK_DOUBLE) + 2; /* FIXME: this is pretty much an abuse of vls. should be using * vlb for variable-length byte buffers. @@ -412,9 +412,14 @@ register int i; register int nused = vp->nused; register point_t *pt = vp->pt; - for (i = 0; i < nused; i++, pt++) { - htond(bp, (unsigned char *)pt, 3); - bp += 3*8; + + /* must be double for import and export */ + double point[ELEMENTS_PER_POINT]; + + for (i = 0; i < nused; i++) { + VMOVE(point, pt[i]); /* convert fastf_t to double */ + htond(bp, (unsigned char *)point, ELEMENTS_PER_VECT); + bp += ELEMENTS_PER_VECT*SIZEOF_NETWORK_DOUBLE; } } } @@ -432,8 +437,10 @@ size_t nelem; size_t namelen; size_t i; - point_t point; + /* must be double for import and export */ + double point[ELEMENTS_PER_POINT]; + BU_CK_VLS(namevls); nelem = ntohl(*(uint32_t *)buf); @@ -449,8 +456,8 @@ int cmd; cmd = *bp++; - ntohd((unsigned char *)point, pp, 3); - pp += 3*8; + ntohd((unsigned char *)point, pp, ELEMENTS_PER_POINT); + pp += ELEMENTS_PER_POINT*SIZEOF_NETWORK_DOUBLE; BN_ADD_VLIST(&rt_g.rtg_vlfree, hp, point, cmd); } } @@ -629,7 +636,7 @@ size_t ret; int i, j; int cc = 0; - char inbuf[8] = {'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'}; + char inbuf[SIZEOF_NETWORK_DOUBLE] = {'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'}; for (i = 0; i < up->narg; i++) { switch (up->targ) { @@ -637,12 +644,15 @@ arg[i] = getshort(fp); break; case TIEEE: - ret = fread(inbuf, 8, 1, fp); + { + double scan; + ret = fread(inbuf, SIZEOF_NETWORK_DOUBLE, 1, fp); if (ret != 1) bu_log("WARNING: uplot read failure\n"); - ntohd((unsigned char *)&arg[i], - (unsigned char *)inbuf, 1); + ntohd((unsigned char *)&scan, (unsigned char *)inbuf, 1); + arg[i] = scan; /* convert double to fastf_t */ break; + } case TSTRING: j = 0; while (!feof(fp) && This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53654] brlcad/trunk/src/librt From: <brlcad@us...> - 2012-11-11 06:04 Revision: 53654 http://brlcad.svn.sourceforge.net/brlcad/?rev=53654&view=rev Author: brlcad Date: 2012-11-11 06:04:42 +0000 (Sun, 11 Nov 2012) Log Message: ----------- stop two memory leaks reported by valgrind. free what we initialized. Modified Paths: -------------- brlcad/trunk/src/librt/db_tree.c brlcad/trunk/src/librt/tree.c Modified: brlcad/trunk/src/librt/db_tree.c =================================================================== --- brlcad/trunk/src/librt/db_tree.c 2012-11-11 06:03:13 UTC (rev 53653) +++ brlcad/trunk/src/librt/db_tree.c 2012-11-11 06:04:42 UTC (rev 53654) @@ -972,12 +972,21 @@ RT_CK_DBTS(tsp); - if (*orig_str == '\0') return 0; /* Null string */ + if (*orig_str == '\0') { + return 0; /* Null string */ + } - if (db_string_to_path(&new_path, tsp->ts_dbip, orig_str) < 0) + db_full_path_init(&new_path); + + if (db_string_to_path(&new_path, tsp->ts_dbip, orig_str) < 0) { + db_free_full_path(&new_path); return -1; + } - if (new_path.fp_len <= 0) return 0; /* Null string */ + if (new_path.fp_len <= 0) { + db_free_full_path(&new_path); + return 0; /* Null string */ + } ret = db_follow_path(tsp, total_path, &new_path, noisy, 0); db_free_full_path(&new_path); Modified: brlcad/trunk/src/librt/tree.c =================================================================== --- brlcad/trunk/src/librt/tree.c 2012-11-11 06:03:13 UTC (rev 53653) +++ brlcad/trunk/src/librt/tree.c 2012-11-11 06:04:42 UTC (rev 53654) @@ -181,12 +181,14 @@ return TREE_NULL; bu_avs_init_empty(&avs); - if (!db5_get_attributes(tsp->ts_dbip, &avs, dp)) { + if (db5_get_attributes(tsp->ts_dbip, &avs, dp) == 0) { + /* copy avs */ bu_avs_init_empty(&(rp->attr_values)); - for(BU_AVS_FOR(avpp, &(tsp->ts_attrs))) { + for (BU_AVS_FOR(avpp, &(tsp->ts_attrs))) { bu_avs_add(&(rp->attr_values), avpp->name, bu_avs_get(&avs, avpp->name)); } } + bu_avs_free(&avs); rp->reg_mater = tsp->ts_mater; /* struct copy */ if (tsp->ts_mater.ma_shader) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53666] brlcad/trunk/src/librt From: <n_reed@us...> - 2012-11-13 21:42 Revision: 53666 http://brlcad.svn.sourceforge.net/brlcad/?rev=53666&view=rev Author: n_reed Date: 2012-11-13 21:42:11 +0000 (Tue, 13 Nov 2012) Log Message: ----------- add primitive routine for calculating a curve count based on bbox dimensions and curve spacing parameter Modified Paths: -------------- brlcad/trunk/src/librt/librt_private.h brlcad/trunk/src/librt/primitives/primitive_util.c Modified: brlcad/trunk/src/librt/librt_private.h =================================================================== --- brlcad/trunk/src/librt/librt_private.h 2012-11-13 21:35:20 UTC (rev 53665) +++ brlcad/trunk/src/librt/librt_private.h 2012-11-13 21:42:11 UTC (rev 53666) @@ -104,6 +104,10 @@ fastf_t p, int num_new_points); +extern fastf_t primitive_curve_count( + struct rt_db_internal *ip, + const struct rt_view_info *info); + extern int approximate_hyperbolic_curve( struct rt_pt_node *pts, fastf_t a, Modified: brlcad/trunk/src/librt/primitives/primitive_util.c =================================================================== --- brlcad/trunk/src/librt/primitives/primitive_util.c 2012-11-13 21:35:20 UTC (rev 53665) +++ brlcad/trunk/src/librt/primitives/primitive_util.c 2012-11-13 21:42:11 UTC (rev 53666) @@ -92,6 +92,33 @@ return diagonal_samples; } +/** + * Estimate the number of evenly spaced cross-section curves needed to meet a + * target curve spacing. + */ +fastf_t +primitive_curve_count( + struct rt_db_internal *ip, + const struct rt_view_info *info) +{ + point_t bbox_min, bbox_max; + fastf_t x_len, y_len, z_len, avg_len; + + if (!ip->idb_meth->ft_bbox) { + return 0.0; + } + + ip->idb_meth->ft_bbox(ip, &bbox_min, &bbox_max, info->tol); + + x_len = fabs(bbox_max[X] - bbox_min[X]); + y_len = fabs(bbox_max[Y] - bbox_min[Y]); + z_len = fabs(bbox_max[Z] - bbox_min[Z]); + + avg_len = (x_len + y_len + z_len) / 3.0; + + return avg_len / info->curve_spacing; +} + /* Calculate the length of the shortest distance between a point and a line in * the y-z plane. */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53763] brlcad/trunk/src/librt From: <brlcad@us...> - 2012-11-19 20:52 Revision: 53763 http://brlcad.svn.sourceforge.net/brlcad/?rev=53763&view=rev Author: brlcad Date: 2012-11-19 20:52:24 +0000 (Mon, 19 Nov 2012) Log Message: ----------- no longer need to manually clear the bitv, rt_get_solidbitv() does it for us Modified Paths: -------------- brlcad/trunk/src/librt/bundle.c brlcad/trunk/src/librt/shoot.c brlcad/trunk/src/librt/vshoot.c Modified: brlcad/trunk/src/librt/bundle.c =================================================================== --- brlcad/trunk/src/librt/bundle.c 2012-11-19 20:48:36 UTC (rev 53762) +++ brlcad/trunk/src/librt/bundle.c 2012-11-19 20:52:24 UTC (rev 53763) @@ -167,7 +167,6 @@ } solidbits = rt_get_solidbitv(rtip->nsolids, resp); - bu_bitv_clear(solidbits); if (BU_LIST_IS_EMPTY(&resp->re_region_ptbl)) { BU_GET(regionbits, struct bu_ptbl); Modified: brlcad/trunk/src/librt/shoot.c =================================================================== --- brlcad/trunk/src/librt/shoot.c 2012-11-19 20:48:36 UTC (rev 53762) +++ brlcad/trunk/src/librt/shoot.c 2012-11-19 20:52:24 UTC (rev 53763) @@ -700,7 +700,6 @@ * intersection calculations */ solidbits = rt_get_solidbitv(rtip->nsolids, resp); - bu_bitv_clear(solidbits); ray = ss->ap->a_ray; /* struct copy, don't mess with the original */ @@ -1017,7 +1016,6 @@ BU_ASSERT_PTR(BU_PTBL_GET(&rtip->rti_resources, resp->re_cpu), !=, NULL); solidbits = rt_get_solidbitv(rtip->nsolids, resp); - bu_bitv_clear(solidbits); if (BU_LIST_IS_EMPTY(&resp->re_region_ptbl)) { BU_GET(regionbits, struct bu_ptbl); @@ -1198,7 +1196,6 @@ * point and using pieces) */ backbits = rt_get_solidbitv(rtip->nsolids, resp); - bu_bitv_clear(backbits); /* call "rt_find_backing_dist()" to calculate the required * start point for calculation, and to fill in the Modified: brlcad/trunk/src/librt/vshoot.c =================================================================== --- brlcad/trunk/src/librt/vshoot.c 2012-11-19 20:48:36 UTC (rev 53762) +++ brlcad/trunk/src/librt/vshoot.c 2012-11-19 20:52:24 UTC (rev 53763) @@ -172,7 +172,6 @@ HeadSeg = RT_SEG_NULL; solidbits = rt_get_solidbitv(rtip->nsolids, ap->a_resource); - bu_bitv_clear(solidbits); if (BU_LIST_IS_EMPTY(&ap->a_resource->re_region_ptbl)) { BU_GET(regionbits, struct bu_ptbl); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53805] brlcad/trunk/src/librt From: <brlcad@us...> - 2012-11-24 16:46 Revision: 53805 http://brlcad.svn.sourceforge.net/brlcad/?rev=53805&view=rev Author: brlcad Date: 2012-11-24 16:46:19 +0000 (Sat, 24 Nov 2012) Log Message: ----------- rename brep_test to test_dvec Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt brlcad/trunk/src/librt/Makefile.am Added Paths: ----------- brlcad/trunk/src/librt/test_dvec.cpp Removed Paths: ------------- brlcad/trunk/src/librt/brep_test.cpp Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2012-11-24 16:42:06 UTC (rev 53804) +++ brlcad/trunk/src/librt/CMakeLists.txt 2012-11-24 16:46:19 UTC (rev 53805) @@ -245,7 +245,7 @@ ) set(librt_ignored_files - brep_test.cpp + test_dvec.cpp columnparse.c librt.3 librt_private.h Modified: brlcad/trunk/src/librt/Makefile.am =================================================================== --- brlcad/trunk/src/librt/Makefile.am 2012-11-24 16:42:06 UTC (rev 53804) +++ brlcad/trunk/src/librt/Makefile.am 2012-11-24 16:46:19 UTC (rev 53805) @@ -4,14 +4,14 @@ librt_nil.la \ librt_xxx.la -BREP_TEST = brep_test BREP_CPPFLAGS = ${SSE} -DOBJ_BREP=1 ${TNT_CPPFLAGS} ${OPENNURBS_CPPFLAGS} BREP_LIBADD = ${OPENNURBS} ${NURBS} ${NURBS_LIBS} -brep_test_SOURCES = brep_test.cpp +TEST_DVEC = test_dvec +test_dvec_SOURCES = test_dvec.cpp # cannot set per-target CPPFLAGS until automake 1.7+ -brep_test_CXXFLAGS = ${SSE} -brep_test_LDADD = \ +test_dvec_CXXFLAGS = ${SSE} +test_dvec_LDADD = \ librt.la \ ${RT_LIBS} @@ -24,7 +24,7 @@ AM_CFLAGS = ${STRICT_FLAGS} noinst_PROGRAMS = \ - ${BREP_TEST} \ + ${TEST_DVEC} \ namegen \ nurb_example \ parsetest \ Deleted: brlcad/trunk/src/librt/brep_test.cpp =================================================================== --- brlcad/trunk/src/librt/brep_test.cpp 2012-11-24 16:42:06 UTC (rev 53804) +++ brlcad/trunk/src/librt/brep_test.cpp 2012-11-24 16:46:19 UTC (rev 53805) @@ -1,187 +0,0 @@ -/* B R E P _ T E S T . C P P - * BRL-CAD - * - * Copyright (c) 2008-2012 United States Government as represented by - * the U.S. Army Research Laboratory. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public License - * version 2.1 as published by the Free Software Foundation. - * - * This library is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this file; see the file named COPYING for more - * information. - */ - -#include <stdio.h> -#include <stdlib.h> -#include <iostream> -#include <assert.h> -#include "vmath.h" -#include "brep.h" -#include "dvec.h" - - -const int COUNT = 100000000; - -int -main(int argc, char** argv) -{ - if (argc > 1) - printf("Usage: %s\n", argv[0]); - -#ifdef __x86_vector__ - printf("using x86 vectorization\n"); -#elif defined(__fpu_vector__) - printf("using fpu vectorization\n"); -#endif - - { - // test correctness - double _a[8] VEC_ALIGN = {0, 1, 2, 3, 4, 5, 6, 7}; - double _b[8] VEC_ALIGN = {2, 4, 6, 8, 10, 12, 14, 16}; - dvec<8> a(_a); - dvec<8> b(_b); - - dvec<8> c = a + b; - double _c[8] VEC_ALIGN = {2, 5, 8, 11, 14, 17, 20, 23}; - assert(c == dvec<8>(_c)); - - dvec<8> d = a - b; - double _d[8] VEC_ALIGN = {-2, -3, -4, -5, -6, -7, -8, -9}; - assert(d == dvec<8>(_d)); - - dvec<8> e = a * b; - double _e[8] VEC_ALIGN = {0, 4, 12, 24, 40, 60, 84, 112}; - assert(e == dvec<8>(_e)); - - dvec<8> f = a / b; - double _f[8] VEC_ALIGN = {0, 0.25, 0.333333333333, 0.375, 0.40, 0.4166666666, 0.42857142, 0.4375}; - assert(f == dvec<8>(_f)); - - dvec<8> g = a.madd(c, b); - double _g[8] VEC_ALIGN = {2, 9, 22, 41, 66, 97, 134, 177}; - assert(g == dvec<8>(_g)); - - dvec<8> h = a.madd(2.0, b); - double _h[8] VEC_ALIGN = {2, 6, 10, 14, 18, 22, 26, 30}; - assert(h == dvec<8>(_h)); - - srand(time(NULL)); - double total = 0.0; - double rval[] = { - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0 }; - - clock_t start = clock(); - for (int i = 0; i < COUNT; i++) { - double l_a[8] VEC_ALIGN = {rval[i%8], rval[i%8+1], rval[i%8+2], rval[i%8+3], - rval[i%8+4], rval[i%8+5], rval[i%8+6], rval[i%8+7]}; - double l_b[8] VEC_ALIGN = {rval[i%8+1], rval[i%8+2], rval[i%8+3], rval[i%8+4], - rval[i%8+5], rval[i%8+6], rval[i%8+7], rval[i%8+8]}; - - dvec<8> la(l_a); - dvec<8> lb(l_b); - - dvec<8> lc = la + lb; - dvec<8> ld = lc - la; - dvec<8> le = ld * lc; - dvec<8> lf = le / la; - dvec<8> lg = la.madd(rval[i%16], lf); - dvec<8> lh = lg.madd(lf, la+lb*lc-ld/le*lf); - total += lh[7]; - } - printf("dvec<8> time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); - } - -/* test correctness */ - vec2d a(100.0, -100.0); - vec2d b(200.0, -200.0); - - vec2d c = a + b; - assert(vequals(c, vec2d(300.0, -300.0))); - - vec2d d = a - b; - assert(vequals(d, vec2d(-100.0, 100.0))); - - vec2d e = a * b; - assert(vequals(e, vec2d(20000.0, 20000.0))); - - vec2d f = b / a; - assert(vequals(f, vec2d(2.0, 2.0))); - - vec2d g = a.madd(20.0, b); - assert(vequals(g, vec2d(2200.0, -2200.0))); - - vec2d h = a.madd(d, b); - assert(vequals(h, vec2d(-9800.0, -10200.0))); - -/* simple performance test */ - - srand(time(NULL)); - double total = 0.0; - double rval[] = { - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0 }; - - clock_t start = clock(); - for (int i = 0; i < COUNT; i++) { - vec2d la(rval[i%12], rval[i%12+2]); - vec2d lb(rval[i%12+1], rval[i%12+3]); - - vec2d lc = la + lb; - vec2d ld = lc - la; - vec2d le = ld * lc; - vec2d lf = le / la; - vec2d lg = la.madd(rval[i%12], lf); - vec2d lh = lg.madd(lg, la + lb - lc + ld - le + lf); - total += lh.x() + lh.y(); - } - printf("vec2d time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); - - return total > 0; -} - - -// Local Variables: -// tab-width: 8 -// mode: C++ -// c-basic-offset: 4 -// indent-tabs-mode: t -// c-file-style: "stroustrup" -// End: -// ex: shiftwidth=4 tabstop=8 Copied: brlcad/trunk/src/librt/test_dvec.cpp (from rev 53804, brlcad/trunk/src/librt/brep_test.cpp) =================================================================== --- brlcad/trunk/src/librt/test_dvec.cpp (rev 0) +++ brlcad/trunk/src/librt/test_dvec.cpp 2012-11-24 16:46:19 UTC (rev 53805) @@ -0,0 +1,187 @@ +/* B R E P _ T E S T . C P P + * BRL-CAD + * + * Copyright (c) 2008-2012 United States Government as represented by + * the U.S. Army Research Laboratory. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * version 2.1 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this file; see the file named COPYING for more + * information. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <iostream> +#include <assert.h> +#include "vmath.h" +#include "brep.h" +#include "dvec.h" + + +const int COUNT = 100000000; + +int +main(int argc, char** argv) +{ + if (argc > 1) + printf("Usage: %s\n", argv[0]); + +#ifdef __x86_vector__ + printf("using x86 vectorization\n"); +#elif defined(__fpu_vector__) + printf("using fpu vectorization\n"); +#endif + + { + // test correctness + double _a[8] VEC_ALIGN = {0, 1, 2, 3, 4, 5, 6, 7}; + double _b[8] VEC_ALIGN = {2, 4, 6, 8, 10, 12, 14, 16}; + dvec<8> a(_a); + dvec<8> b(_b); + + dvec<8> c = a + b; + double _c[8] VEC_ALIGN = {2, 5, 8, 11, 14, 17, 20, 23}; + assert(c == dvec<8>(_c)); + + dvec<8> d = a - b; + double _d[8] VEC_ALIGN = {-2, -3, -4, -5, -6, -7, -8, -9}; + assert(d == dvec<8>(_d)); + + dvec<8> e = a * b; + double _e[8] VEC_ALIGN = {0, 4, 12, 24, 40, 60, 84, 112}; + assert(e == dvec<8>(_e)); + + dvec<8> f = a / b; + double _f[8] VEC_ALIGN = {0, 0.25, 0.333333333333, 0.375, 0.40, 0.4166666666, 0.42857142, 0.4375}; + assert(f == dvec<8>(_f)); + + dvec<8> g = a.madd(c, b); + double _g[8] VEC_ALIGN = {2, 9, 22, 41, 66, 97, 134, 177}; + assert(g == dvec<8>(_g)); + + dvec<8> h = a.madd(2.0, b); + double _h[8] VEC_ALIGN = {2, 6, 10, 14, 18, 22, 26, 30}; + assert(h == dvec<8>(_h)); + + srand(time(NULL)); + double total = 0.0; + double rval[] = { + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0 }; + + clock_t start = clock(); + for (int i = 0; i < COUNT; i++) { + double l_a[8] VEC_ALIGN = {rval[i%8], rval[i%8+1], rval[i%8+2], rval[i%8+3], + rval[i%8+4], rval[i%8+5], rval[i%8+6], rval[i%8+7]}; + double l_b[8] VEC_ALIGN = {rval[i%8+1], rval[i%8+2], rval[i%8+3], rval[i%8+4], + rval[i%8+5], rval[i%8+6], rval[i%8+7], rval[i%8+8]}; + + dvec<8> la(l_a); + dvec<8> lb(l_b); + + dvec<8> lc = la + lb; + dvec<8> ld = lc - la; + dvec<8> le = ld * lc; + dvec<8> lf = le / la; + dvec<8> lg = la.madd(rval[i%16], lf); + dvec<8> lh = lg.madd(lf, la+lb*lc-ld/le*lf); + total += lh[7]; + } + printf("dvec<8> time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); + } + +/* test correctness */ + vec2d a(100.0, -100.0); + vec2d b(200.0, -200.0); + + vec2d c = a + b; + assert(vequals(c, vec2d(300.0, -300.0))); + + vec2d d = a - b; + assert(vequals(d, vec2d(-100.0, 100.0))); + + vec2d e = a * b; + assert(vequals(e, vec2d(20000.0, 20000.0))); + + vec2d f = b / a; + assert(vequals(f, vec2d(2.0, 2.0))); + + vec2d g = a.madd(20.0, b); + assert(vequals(g, vec2d(2200.0, -2200.0))); + + vec2d h = a.madd(d, b); + assert(vequals(h, vec2d(-9800.0, -10200.0))); + +/* simple performance test */ + + srand(time(NULL)); + double total = 0.0; + double rval[] = { + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0 }; + + clock_t start = clock(); + for (int i = 0; i < COUNT; i++) { + vec2d la(rval[i%12], rval[i%12+2]); + vec2d lb(rval[i%12+1], rval[i%12+3]); + + vec2d lc = la + lb; + vec2d ld = lc - la; + vec2d le = ld * lc; + vec2d lf = le / la; + vec2d lg = la.madd(rval[i%12], lf); + vec2d lh = lg.madd(lg, la + lb - lc + ld - le + lf); + total += lh.x() + lh.y(); + } + printf("vec2d time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); + + return total > 0; +} + + +// Local Variables: +// tab-width: 8 +// mode: C++ +// c-basic-offset: 4 +// indent-tabs-mode: t +// c-file-style: "stroustrup" +// End: +// ex: shiftwidth=4 tabstop=8 This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53874] brlcad/trunk/src/librt From: <carlmoore@us...> - 2012-11-28 20:11 Revision: 53874 http://brlcad.svn.sourceforge.net/brlcad/?rev=53874&view=rev Author: carlmoore Date: 2012-11-28 20:11:46 +0000 (Wed, 28 Nov 2012) Log Message: ----------- fix spelling of Compatibility Modified Paths: -------------- brlcad/trunk/src/librt/prep.c brlcad/trunk/src/librt/timer42.c brlcad/trunk/src/librt/timerunix.c Modified: brlcad/trunk/src/librt/prep.c =================================================================== --- brlcad/trunk/src/librt/prep.c 2012-11-28 20:04:09 UTC (rev 53873) +++ brlcad/trunk/src/librt/prep.c 2012-11-28 20:11:46 UTC (rev 53874) @@ -433,7 +433,7 @@ /** - * Compatability stub. Only uses 1 CPU. + * Compatibility stub. Only uses 1 CPU. */ void rt_prep(register struct rt_i *rtip) Modified: brlcad/trunk/src/librt/timer42.c =================================================================== --- brlcad/trunk/src/librt/timer42.c 2012-11-28 20:04:09 UTC (rev 53873) +++ brlcad/trunk/src/librt/timer42.c 2012-11-28 20:11:46 UTC (rev 53874) @@ -228,7 +228,7 @@ /** - * Compatability routine + * Compatibility routine */ double rt_read_timer(char *str, int len) Modified: brlcad/trunk/src/librt/timerunix.c =================================================================== --- brlcad/trunk/src/librt/timerunix.c 2012-11-28 20:04:09 UTC (rev 53873) +++ brlcad/trunk/src/librt/timerunix.c 2012-11-28 20:11:46 UTC (rev 53874) @@ -116,7 +116,7 @@ /** - * Compatability routine + * Compatibility routine */ double rt_read_timer(char *str, int len) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[53948] brlcad/trunk/src/librt From: <starseeker@us...> - 2012-12-02 20:21 Revision: 53948 http://brlcad.svn.sourceforge.net/brlcad/?rev=53948&view=rev Author: starseeker Date: 2012-12-02 20:21:10 +0000 (Sun, 02 Dec 2012) Log Message: ----------- Caught a leftover .3 file that has an xml file - remove. Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt brlcad/trunk/src/librt/Makefile.am Removed Paths: ------------- brlcad/trunk/src/librt/librt.3 Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2012-12-02 19:48:48 UTC (rev 53947) +++ brlcad/trunk/src/librt/CMakeLists.txt 2012-12-02 20:21:10 UTC (rev 53948) @@ -299,7 +299,6 @@ endif(BRLCAD_BUILD_STATIC_LIBS AND BRLCAD_ENABLE_BRLCAD_LIBRARY) endif(CPP_DLL_DEFINES) -install(FILES librt.3 DESTINATION ${MAN_DIR}/man3) CMAKEFILES(Makefile.am) include_directories( Modified: brlcad/trunk/src/librt/Makefile.am =================================================================== --- brlcad/trunk/src/librt/Makefile.am 2012-12-02 19:48:48 UTC (rev 53947) +++ brlcad/trunk/src/librt/Makefile.am 2012-12-02 20:21:10 UTC (rev 53948) @@ -301,8 +301,6 @@ primitives/revolve/revolve.h \ primitives/xxx/xxx.h -dist_man_MANS = librt.3 - sample_applicationsdir = $(SAMPLE_APPLICATIONS_DIR) sample_applications_DATA = \ Deleted: brlcad/trunk/src/librt/librt.3 =================================================================== --- brlcad/trunk/src/librt/librt.3 2012-12-02 19:48:48 UTC (rev 53947) +++ brlcad/trunk/src/librt/librt.3 2012-12-02 20:21:10 UTC (rev 53948) @@ -1,470 +0,0 @@ -.TH LIBRT 3 BRL-CAD -.\" L I B R T . 3 -.\" BRL-CAD -.\" -.\" Copyright (c) 1986-2012 United States Government as represented by -.\" the U.S. Army Research Laboratory. -.\" -.\" Redistribution and use in source (Docbook format) and 'compiled' -.\" forms (PDF, PostScript, HTML, RTF, etc.), with or without -.\" modification, are permitted provided that the following conditions -.\" are met: -.\" -.\" 1. Redistributions of source code (Docbook format) must retain the -.\" above copyright notice, this list of conditions and the following -.\" disclaimer. -.\" -.\" 2. Redistributions in compiled form (transformed to other DTDs, -.\" converted to PDF, PostScript, HTML, RTF, and other formats) must -.\" reproduce the above copyright notice, this list of conditions and -.\" the following disclaimer in the documentation and/or other -.\" materials provided with the distribution. -.\" -.\" 3. The name of the author may not be used to endorse or promote -.\" products derived from this documentation without specific prior -.\" written permission. -.\" -.\" THIS DOCUMENTATION IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY -.\" EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -.\" PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR -.\" ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -.\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT -.\" OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR -.\" BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -.\" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE -.\" USE OF THIS DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF -.\" SUCH DAMAGE. -.\" -.\".\".\" -.SH NAME -librt \- library for raytracing an MGED database -.SH SYNOPSIS -.nf -\fB#include "vmath.h" -\fB#include "raytrace.h" -.sp -WARNING - WARNING - WARNING - WARNING - WARNING - -This file seems to be out of date with the sources. -Consult the headers for up-to-date information. -Use the below interface documentation at your own discretion. - -WARNING - WARNING - WARNING - WARNING - WARNING -.sp -extern struct rt_functab rt_functab[\|]; -extern struct rt_g rt_g; -.sp -struct rt_i *rt_dirbuild( mged_file_name, buf, len ) -char *mged_file_name; -char *buf; -int len; -.sp -int rt_gettree( rtip, object_name ) -struct rt_i *rtip; -char *object_name; -.sp -void rt_prep( rtip ) -struct rt_i *rtip; -.sp -int rt_shootray( ap ) -struct application *ap; -.sp -void rt_prep_timer(\|) -.sp -double rt_read_timer( buf, len ) -char *buf; -int len; -.sp -void rt_pr_partitions( rtip, phead, title ) -struct rt_i *rtip -struct partition *phead; -char *title; -.sp -void rt_pr_seg( segp ); -struct seg *segp; -.sp -struct soltab *rt_find_solid(\|) -.SH DESCRIPTION -.I rt_dirbuild\^ -opens -.I mged_file_name -and builds a directory for quick lookup of objects. -.I rt_dirbuild\^ -returns a pointer to a -.I "struct rt_i" -on success (often called ``\fIrtip\fP''), -or -.I RTI_NULL -on failure (such as being unable to open the named database). -This pointer must be saved, as it is a required parameter to -.IR rt_gettree . -The user-supplied buffer -.I buf\^ -is filled with up to -.I len -characters -of information from the first title record in the database. -If it is desired for ``air'' objects to be reported as ``hits'' -during ray-tracing, then the -.I useair -member of the -.I "struct rt_i" -must be set before the first call to -.IR rt_gettree . -.P -All objects (groups and regions) which are to be included in the description -to be raytraced must be preprocessed with -.IR rt_gettree , -which returns \-1 for failure and 0 for success. -This function can be called as many times as required. -Be certain to pass the -.I "struct rt_i" -pointer from -.I rt_dirbuild\^ -each time. -.P -After the last -.I rt_gettree -call, -.I rt_prep -can be called to complete the preparation of internal data structures. -If -.I rt_prep -is not explicitly called, it will be indirectly invoked by the first use of -.IR rt_shootray . -.P -To fire a ray at the model, an -.I application -structure must be -prepared and its address passed to -.IR rt_shootray . -Note that it is mandatory that you provide values for -.I a_ray.r_pt -(the starting point of the ray to be fired), -.I a_ray.r_dir -(a unit-length direction vector), -.I a_hit -(address of user-supplied hit routine), -.I a_miss -(address of user-supplied miss routine), -.I a_overlap -(address of user-supplied overlap routine; may be null), -.I a_rt_i -(\fIstruct rt_i\fP pointer, from -.IR rt_dirbuild ), -.I a_onehit -(flag controlling stop after first hit), -.I a_level\^ -(recursion level, just for diagnostic printing), -and -.I a_resource -(address of -.I resource -structure; may be null). -.P -To obtain a report of CPU usage for a portion or portions of your program, -frame the statements with calls to -.I rt_prep_timer -and -.IR rt_read_timer . -Each call to -.I rt_prep_timer -resets the timing process, after which -.I rt_read_timer -can be called to get -a double which is the elapsed CPU time in seconds since -.I rt_prep_timer -was last called. -In addition, up to -.I len -bytes of -system-specific detailing of resource consumption -is placed in the user-supplied buffer -.IR buf . -.P -.I bu_bomb -can be used to exit your program with -.I msg -printed on the standard error output. -.SH WARNING -.I Librt -is designed to run in parallel on some multiprocessor machines. -On some such machines -system calls must be semaphore protected. -.P -Dynamic memory handling in applications using -.I librt -should use -the functions provided by -.I libbu -instead of the usual system runtime library -routines. The -.I libbu -versions do not return to the caller unless they succeed. If they fail, -they call -.I bu_bomb -with their last argument (str) as the parameter. The string parameter -usually indicates the purpose of the memory being allocated. -.P -.SH "EXIT CODE" -All truly fatal errors detected by the library use -.I bu_bomb -to exit with a status of 12. -.SH DEFINITION -RPP \- Rectangular ParallelePiped. -A region of space defined by minimum and maximum values in X, Y, and Z. -RPPs are used by -.I librt -as bounding volumes for solids. -.SH DISCUSSION -You should study the structures in -.IR raytrace.h , -in particular, the -.I application -structure, -the -.I partition -structure and its component structures to get an idea of what information -is handed to/from -.IR rt_shootray . -.I rt_shootray -may be called recursively from your -.I a_hit -routine (good for doing bounced rays). -If you only care about the first -object hit along the path of the ray, set the -.I a_onehit -flag in the application structure before calling -.IR rt_shootray . -.I rt_shootray -returns the return value of the user-supplied hit or miss function -that it called. -.P -If the ray intersects the model, the -.I a_hit -routine is called -with a pointer to the application structure and a pointer to a -linked list of ray partitions -(\fIstruct partition\fP). -Within each partition are -.I seg -(solid segment) -and -.I hit -(intersection with evaluated region) -structure pointers -for the places where the ray enters and leaves this partition of space. -.I pt_inhit.hit_dist -is the parametric distance at which the ray enters -the partition, and -.I pt_outhit.hit_dist -is the parametric distance at which the ray leaves. -Note that while the -.I hit -structure contains -.I hit_point -and -.I hit_norm -elements, they are not computed by -.IR rt_shootray . -If these are needed, they can be filled in by using the -.I RT_HIT_NORMAL\^ -macro; -if surface curvature information is needed, -it can be obtained by using the -.I RT_CURVE\^ -macro after -.IR RT_HIT_NORMAL ; -if only the -.I hit_point -is needed, -it can be filled in by using the -.I VJOIN1\^ -macro (see the following example). -.P -If the ray contains any overlaps -(partitions claimed by two or more regions) the -.I a_overlap -routine is called for each such partition -with pointers to the application structure, -the overlap partition, -two regions, -and the remaining partitions along the ray. -If the -.I a_overlap -member is null, -.I librt -uses a default overlap handler. -Additionally, -.I librt -provides the routine -.P -If the ray does not intersect the model, the -.I a_miss -routine is called -with a pointer to the application structure. -.P -Helpful in generating a grid of ray origins, the bounding RPP of the -model is computed by -.I rt_gettree -and is stored in -.I rtip\->mdl_min -and -.IR rtip\->mdl_max . -.SH EXAMPLE -.PP -A program can be loaded as follows: -.sp -$ \|\fIcc \|\-I/usr/brlcad/include \|main.c \|/usr/brlcad/lib/librt.a \|\-l<system-specific> \|\-lm\fP -.sp -where -.I <system-specific> -indicates libraries required on a particular architecture. The table below -indicates which system specific libraries are necessary on a particular -architecture. -.PP - Architecture Librarie(s) - Alliant FX/8 -lcvec -lcommon - Alliant FX/2800 -lcommon - SGI 4D -lmpc - Cray(X/Y) -L/lib/multi -lu -lio - Cray2 -lmt - Encore Multi-Max -lpp -.sp -Here is a portion of a hypothetical program which uses the library: -.RS -.sp -.nf -#include <vmath.h> -#include <raytrace.h> -main( argc, argv ) -int argc; -char *argv[\|]; -{ - static int do_if_hit(\|), do_if_miss(\|); /* Application routines */ - register int h, v; - int grid_sz; - struct application ap; /* Set up for rt_shootray(\|) */ - struct rt_i *rtip; - /* \s+2...\s0\& */ - - /* Build the directory. */ - rtip = rt_dirbuild( argv[bu_optind++] ); - - /* Load the desired portion of the model. */ - while( argv[bu_optind] != NULL ) - rt_gettree( rtip, argv[bu_optind++] ); - - ap.a_hit = do_if_hit; /* Supply routine for hit */ - ap.a_miss = do_if_missed; /* Supply routine for miss */ - ap.a_overlap = 0; - ap.a_rt_i = rtip; - ap.a_level = 0; - ap.a_onehit = 0; /* Return all objects along ray */ - ap.a_resource = 0; - - for( v = 0; v < grid_sz; ++v ) /* For each scanline */ - for( h = 0; h < grid_sz; ++h ) { - /* Set up ray origin. */ - VMOVE( ap.a_ray.r_pt, get_grid( h, v ) ); - /* Compute ray direction. */ - VMOVE( ap.a_ray.r_dir, get_dir( h, v ) ); - /* Must be unit vector. */ - VUNITIZE( ap.a_ray.r_dir ); - (void) rt_shootray( &ap ); - } - /* \s+2...\s0\& */ -} - -static int -do_if_hit( ap, PartHeadp ) -register struct application *ap; -struct partition *PartHeadp; -{ - extern void put_component(); - struct curvature incurv; - register struct partition *pp; - - for( pp = PartHeadp\->pt_forw; pp != PartHeadp; pp = pp\->pt_forw ) { - - /* Fill in all inhit info, but just the exit location for outhit. */ - RT_HIT_NORMAL(pp\->pt_inhit\->hit_normal, pp\->pt_inhit, pp\->pt_inseg\->seg_stp, &ap\->a_ray, pp\->pt_inflip); - RT_CURVE( &incurv, pp\->pt_inhit, pp\->pt_inseg\->seg_stp ); - VJOIN1( pp\->pt_outhit\->hit_point, ap\->a_ray.r_pt, - pp\->pt_outhit\->hit_dist, ap\->a_ray.r_dir ); - - /* Do something based on information in partition structure - * such as output a shotline component data record. - */ - put_component( pp\->pt_inhit, &incurv, pp\->pt_outhit ); - /* \s+2...\s0\& */ - } - return 1; /* Report hit to main routine */ -} - -static int -do_if_missed( ap ) -register struct application *ap; -{ - return 0; /* Report miss to main routine */ -} -.RE -.sp -.SH "SEE ALSO" -mged(1B), rt(1B). -.SH DIAGNOSTICS -``rt_malloc: malloc failure'', -if -.I librt -is unable to allocate memory with -.IR malloc . -``rt_\fI???\fP: read error'', if an error or EOF occurs while -reading from the model database. -``unexpected SIGFPE!'' when a floating point error occurs. -(The rootfinder traps SIGFPE, but SIGFPE elsewhere is unexpected.) -``rt_shootray: zero length dir vector'' when the -.I a_ray.r_dir -vector is not unit length. -``rt_gettree called again after rt_prep!'' when an attempt is made -to add more sub-trees to the active model after calling -.I rt_prep -(or after firing the first ray). -``rt_prep: re-invocation'' when -.I rt_prep -is called more than once. -``rt_prep: no solids to prep'' when there are no valid solids -in the model. -.PP -The LIBRT_DEBUG environment variable may be set to the hexadecimal bit -vector as described by the DEBUG_* flags listed in the raytrace.h -header. Similarly, many LIBRT applications provide a ``-x #'' -command-line option which will take precedence over the environment -variable. -.PP -The LIBRT_V4FLIP environment variable may be set to a true or false -value to respectively force or disable endianness interpretation of v4 -geometry database files. The default behavior is to automatically -detect whether flipping the endian interpretation will help LIBRT read -a binary-incompatible v4 geometry database file. Setting LIBRT_V4FLIP -will override automatic detection. -.PP -The LIBRT_BOT_MINTIE environment variable may be set to the minimum -number of faces a BoT primitive must have to exercise the Triangle -Intersection Engine (TIE) raytrace evaluation. A value less than or -equal to zero will utilize traditional BoT raytracing instead of TIE. -.SH BUGS -On a VAX, the rootfinder detects ``hard'' cases by taking a SIGFPE -and retrying -with a slower but more stable algorithm. -This is unfortunate. - -.SH AUTHOR -BRL-CAD Team -.SH COPYRIGHT -This software is Copyright (c) 1986-2012 United States Government as -represented by the U.S. Army Research Laboratory. All rights reserved. -.SH "BUG REPORTS" -Reports of bugs or problems should be submitted via electronic -mail to <devs@...>. This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54047] brlcad/trunk/src/librt From: <starseeker@us...> - 2012-12-11 22:33 Revision: 54047 http://brlcad.svn.sourceforge.net/brlcad/?rev=54047&view=rev Author: starseeker Date: 2012-12-11 22:33:42 +0000 (Tue, 11 Dec 2012) Log Message: ----------- Add a relatively simple test bot for subdivision - will use later for regression testing. Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt brlcad/trunk/src/librt/test_subdivision.cpp Added Paths: ----------- brlcad/trunk/src/librt/subd_test_bot.asc Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2012-12-11 21:26:55 UTC (rev 54046) +++ brlcad/trunk/src/librt/CMakeLists.txt 2012-12-11 22:33:42 UTC (rev 54047) @@ -252,6 +252,7 @@ test_nurbsfit.cpp test_botpatches.cpp test_subdivision.cpp + subd_test_bot.asc prcomb.c primitives/bot/btg.h primitives/bot/g_bot_include.c Added: brlcad/trunk/src/librt/subd_test_bot.asc =================================================================== --- brlcad/trunk/src/librt/subd_test_bot.asc (rev 0) +++ brlcad/trunk/src/librt/subd_test_bot.asc 2012-12-11 22:33:42 UTC (rev 54047) @@ -0,0 +1,3 @@ +title {sqrt(3) Subdivision Test Bot} +units mm +put {subd.bot} bot mode surface orient rh flags {} V { {0 2 0} {0.5 1 0 } {1 0 0} {1 2 0} {1.5 1 0} {2 0 0} {1.5 3 0} {2 2 0} {2.5 1 0} {3 0 0} {2.5 3 0} {3 2 0}} F { { 0 3 6 } { 3 7 6 } { 7 10 6 } { 7 11 10 } { 0 1 3 } { 1 4 3 } { 3 4 7 } { 4 8 7 } { 7 8 11 } { 1 2 4 } { 2 5 4 } { 4 5 8 } { 5 9 8 } } Property changes on: brlcad/trunk/src/librt/subd_test_bot.asc ___________________________________________________________________ Added: svn:mime-type + text/plain Added: svn:eol-style + native Modified: brlcad/trunk/src/librt/test_subdivision.cpp =================================================================== --- brlcad/trunk/src/librt/test_subdivision.cpp 2012-12-11 21:26:55 UTC (rev 54046) +++ brlcad/trunk/src/librt/test_subdivision.cpp 2012-12-11 22:33:42 UTC (rev 54047) @@ -144,11 +144,12 @@ } // Find outer edge segments and vertices -void get_boundaries(struct Mesh_Info *mesh, std::set<size_t> *outer_pts, std::set<std::pair<size_t, size_t> > *outer_edges) { +void get_boundaries(struct Mesh_Info *mesh, std::set<size_t> *outer_pts, std::set<std::pair<size_t, size_t> > *outer_edges, std::set<size_t> *outer_faces) { std::map<std::pair<size_t, size_t>, std::set<size_t> >::iterator e_it; for (e_it = mesh->edges_to_faces.begin(); e_it!=mesh->edges_to_faces.end(); e_it++) { if ((*e_it).second.size() == 1) { outer_edges->insert((*e_it).first); + outer_faces->insert(*(*e_it).second.begin()); outer_pts->insert((*e_it).first.first); outer_pts->insert((*e_it).first.second); } @@ -178,9 +179,11 @@ get_all_edges(starting_mesh, &old_edges); std::set<std::pair<size_t, size_t> > outer_edges; std::set<size_t > outer_pts; - get_boundaries(starting_mesh, &outer_pts, &outer_edges); + std::set<size_t > outer_faces; + get_boundaries(starting_mesh, &outer_pts, &outer_edges, &outer_faces); std::cout << "outer pt count: " << outer_pts.size() << "\n"; std::cout << "outer edge count: " << outer_edges.size() << "\n"; + std::cout << "outer face count: " << outer_faces.size() << "\n"; // Relax old points here for(size_t pcnt = 0; pcnt < (size_t)starting_mesh->points_p0.Count(); pcnt++) { @@ -220,6 +223,9 @@ std::set<size_t> curr_faces = starting_mesh->edges_to_faces[edge]; curr_faces.erase((*f_it).first); size_t q1 = starting_mesh->index_in_next[*curr_faces.begin()]; + if (outer_faces.find(q0) != outer_faces.end() && outer_faces.find(q1) != outer_faces.end()) { + std::cout << "Got two edge faces\n"; + } mesh_add_face((*e_it).first, q1, q0, face_cnt, mesh); face_cnt++; mesh_add_face((*e_it).second, q0, q1, face_cnt, mesh); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54129] brlcad/trunk/src/librt From: <starseeker@us...> - 2013-01-03 21:41 Revision: 54129 http://brlcad.svn.sourceforge.net/brlcad/?rev=54129&view=rev Author: starseeker Date: 2013-01-03 21:41:33 +0000 (Thu, 03 Jan 2013) Log Message: ----------- Fix compilation with newer opennurbs Modified Paths: -------------- brlcad/trunk/src/librt/test_botpatches.cpp brlcad/trunk/src/librt/test_subdivision.cpp Modified: brlcad/trunk/src/librt/test_botpatches.cpp =================================================================== --- brlcad/trunk/src/librt/test_botpatches.cpp 2013-01-03 17:35:25 UTC (rev 54128) +++ brlcad/trunk/src/librt/test_botpatches.cpp 2013-01-03 21:41:33 UTC (rev 54129) @@ -347,7 +347,7 @@ int b = int(256*drand48() + 1.0); for (v_it = edges->begin(); v_it != edges->end(); v_it++) { pl_color(l_plot, r, g, b); - ON_BrepEdge& edge = info->brep->m_E[(*v_it)]; + ON_BrepEdge& edge = info->brep->m_E[(int)(*v_it)]; const ON_Curve* edge_curve = edge.EdgeCurveOf(); ON_Interval dom = edge_curve->Domain(); // XXX todo: dynamically sample the curve @@ -518,7 +518,7 @@ get_connected_faces(info->bot, face_num, &(info->edge_to_face), &connected_faces); for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { if(faces->find((*cf_it)) != faces->end()) { - if(ON_DotProduct( *(*info).face_normals.At((start_face_num)),*(*info).face_normals.At((*cf_it)) ) > 0.5) { + if(ON_DotProduct( *(*info).face_normals.At((int)(start_face_num)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { face_queue.push((*cf_it)); faces->erase((*cf_it)); } @@ -556,7 +556,7 @@ get_connected_faces(info->bot, face_num_1, &(info->edge_to_face), &connected_faces); for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { if(faces->find((*cf_it)) != faces->end() && (*patches)[new_patch_2].find(*cf_it) == (*patches)[new_patch_2].end()) { - if(ON_DotProduct( *(*info).face_normals.At((start_face_num_1)),*(*info).face_normals.At((*cf_it)) ) > 0.5) { + if(ON_DotProduct( *(*info).face_normals.At((int)(start_face_num_1)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { face_queue_1.push((*cf_it)); faces->erase((*cf_it)); } @@ -573,7 +573,7 @@ get_connected_faces(info->bot, face_num_2, &(info->edge_to_face), &connected_faces); for (cf_it = connected_faces.begin(); cf_it != connected_faces.end(); cf_it++) { if(faces->find((*cf_it)) != faces->end() && (*patches)[new_patch_1].find(*cf_it) == (*patches)[new_patch_1].end()) { - if(ON_DotProduct( *(*info).face_normals.At((start_face_num_2)),*(*info).face_normals.At((*cf_it)) ) > 0.5) { + if(ON_DotProduct( *(*info).face_normals.At(((int)start_face_num_2)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { face_queue_2.push((*cf_it)); faces->erase((*cf_it)); } @@ -701,9 +701,9 @@ VCROSS(norm_dir, a, b); VUNITIZE(norm_dir); info->face_normals.Append(ON_3dVector(norm_dir[0], norm_dir[1], norm_dir[2])); - (*info).face_normals.At(i)->Unitize(); + (*info).face_normals.At((int)i)->Unitize(); for (size_t j=0; j < (size_t)(*info).vectors.Count(); j++) { - vdot = ON_DotProduct(*(*info).vectors.At(j), *(*info).face_normals.At(i)); + vdot = ON_DotProduct(*(*info).vectors.At((int)j), *(*info).face_normals.At((int)i)); info->norm_results[std::make_pair(i, j)] = vdot; if (vdot > result) { result_max = j; @@ -782,7 +782,7 @@ vect_t origin; size_t ok = 1; VMOVE(origin, &info->bot->vertices[info->bot->faces[(face_num)*3]*3]); - ON_Plane plane(ON_3dPoint(origin[0], origin[1], origin[2]), *(*info).face_normals.At((face_num))); + ON_Plane plane(ON_3dPoint(origin[0], origin[1], origin[2]), *(*info).face_normals.At((int)(face_num))); for (int pt = 0; pt < 3; pt++) { point_t cpt; VMOVE(cpt, &info->bot->vertices[info->bot->faces[((*cf_it))*3+pt]*3]); @@ -1067,7 +1067,7 @@ double boxmax[3] = {0.0, 0.0, 0.0}; std::vector<size_t>::iterator v_it; for(v_it = (*l_it).second.begin(); v_it != (*l_it).second.end(); v_it++) { - ON_BrepEdge& edge = info->brep->m_E[(*v_it)]; + ON_BrepEdge& edge = info->brep->m_E[(int)(*v_it)]; const ON_Curve* edge_curve = edge.EdgeCurveOf(); edge_curve->GetBBox((double *)&boxmin, (double *)&boxmax, 1); } @@ -1090,7 +1090,7 @@ // outer and inner trimming loops void build_loop(size_t patch_id, size_t loop_index, ON_BrepLoop::TYPE loop_type, std::map<size_t, std::vector<size_t> > *loops, struct Manifold_Info *info) { - ON_BrepFace& face = info->brep->m_F[patch_id]; + ON_BrepFace& face = info->brep->m_F[(int)patch_id]; // Start with outer loop ON_BrepLoop& loop = info->brep->NewLoop(loop_type, face); // build surface tree @@ -1106,7 +1106,7 @@ for(loop_it = loop_edges->begin(); loop_it != loop_edges->end(); loop_it++) { size_t curr_edge = (*loop_it); // Will we need to flip the trim? - ON_BrepEdge& edge = info->brep->m_E[curr_edge]; + ON_BrepEdge& edge = info->brep->m_E[(int)curr_edge]; if(vert_prev != -1) { if (vert_prev == edge.m_vi[0]) { trim_rev = false; @@ -1189,7 +1189,7 @@ FILE* ploopplot = fopen(bu_vls_addr(&name), "w"); std::set<size_t> curr_edges = (*p_it).second; for (std::set<size_t>::iterator edge_it = curr_edges.begin(); edge_it != curr_edges.end(); edge_it++) { - ON_BrepEdge& edge = info->brep->m_E[(*edge_it)]; + ON_BrepEdge& edge = info->brep->m_E[(int)(*edge_it)]; if (edge.m_vi[0] == edge.m_vi[1]) { size_t curr_loop = loops.size(); loops[curr_loop].push_back((*edge_it)); @@ -1206,12 +1206,12 @@ std::queue<size_t> edge_queue; edge_queue.push(*(curr_edges.begin())); curr_edges.erase(edge_queue.front()); - int vert_to_match = info->brep->m_E[edge_queue.front()].m_vi[0]; + int vert_to_match = info->brep->m_E[(int)edge_queue.front()].m_vi[0]; while (!edge_queue.empty()) { size_t curr_edge = edge_queue.front(); edge_queue.pop(); loops[curr_loop].push_back(curr_edge); - ON_BrepEdge& edge = info->brep->m_E[curr_edge]; + ON_BrepEdge& edge = info->brep->m_E[(int)curr_edge]; if(vert_to_match == edge.m_vi[0]) { vert_to_match = edge.m_vi[1]; } else { @@ -1287,7 +1287,7 @@ std::set<size_t> *patch_edges = &(info->patch_edges[curr_patch]); std::set<size_t>::iterator pe_it; for (pe_it = patch_edges->begin(); pe_it != patch_edges->end(); pe_it++) { - ON_BrepEdge& edge = info->brep->m_E[(*pe_it)]; + ON_BrepEdge& edge = info->brep->m_E[(int)(*pe_it)]; const ON_Curve* edge_curve = edge.EdgeCurveOf(); ON_Interval dom = edge_curve->Domain(); // XXX todo: dynamically sample the curve @@ -1337,7 +1337,7 @@ ON_Interval udom = fit.m_nurbs.Domain(0); ON_Interval vdom = fit.m_nurbs.Domain(1); ON_3dVector surf_norm = fit.m_nurbs.NormalAt(udom.ParameterAt(0.5), vdom.ParameterAt(0.5)); - double vdot = ON_DotProduct(surf_norm, *info->face_normals.At(*(info->patches[(*p_it).first].begin()))); + double vdot = ON_DotProduct(surf_norm, *info->face_normals.At((int)*(info->patches[(*p_it).first].begin()))); if (vdot < 0) { info->brep->FlipFace(face); info->brep2->FlipFace(*face2); Modified: brlcad/trunk/src/librt/test_subdivision.cpp =================================================================== --- brlcad/trunk/src/librt/test_subdivision.cpp 2013-01-03 17:35:25 UTC (rev 54128) +++ brlcad/trunk/src/librt/test_subdivision.cpp 2013-01-03 21:41:33 UTC (rev 54129) @@ -52,9 +52,9 @@ for(f_it = mesh->face_pts.begin(); f_it != mesh->face_pts.end(); f_it++) { ON_3dPoint p1, p2, p3; l_it = (*f_it).second.begin(); - p1 = *mesh->points_p0.At((*l_it)); - p2 = *mesh->points_p0.At((*(l_it+1))); - p3 = *mesh->points_p0.At((*(l_it+2))); + p1 = *mesh->points_p0.At((int)(*l_it)); + p2 = *mesh->points_p0.At((int)(*(l_it+1))); + p3 = *mesh->points_p0.At((int)(*(l_it+2))); ON_3dPoint q((p1.x + p2.x + p3.x)/3, (p1.y + p2.y + p3.y)/3, (p1.z + p2.z + p3.z)/3); mesh->points_q.Append(q); } @@ -73,7 +73,7 @@ range = mesh->point_neighbors.equal_range(p); ON_3dPoint psum = ON_3dPoint(0,0,0); for(p_it = range.first; p_it != range.second; p_it++) { - psum = psum + *mesh->points_p0.At((*p_it).second); + psum = psum + *mesh->points_p0.At((int)(*p_it).second); } fastf_t alpha = alpha_n(n); // @@ -81,7 +81,7 @@ // [pinf = ---------- * psum + -------- * p0] // 3 an n + n 3 an + 1 // - ON_3dPoint pinf = (3*alpha/((3*alpha+1)*n))*psum + 1/(3*alpha+1) * *mesh->points_p0.At(p); + ON_3dPoint pinf = (3*alpha/((3*alpha+1)*n))*psum + 1/(3*alpha+1) * *mesh->points_p0.At((int)p); p_a->Append(pinf); } @@ -90,7 +90,7 @@ size_t n = mesh->point_valence[p]; point_inf(p, mesh, &mesh->points_inf); fastf_t gamma = pow((2/3 - alpha_n(n)),m); - ON_3dPoint subdiv_pt = gamma * *mesh->points_p0.At(p) + (1-gamma) * *mesh->points_inf.At(p); + ON_3dPoint subdiv_pt = gamma * *mesh->points_p0.At((int)p) + (1-gamma) * *mesh->points_inf.At((int)p); p_a->Append(subdiv_pt); } @@ -343,7 +343,7 @@ // Relax old points here for(size_t pcnt = 0; pcnt < (size_t)starting_mesh->points_p0.Count(); pcnt++) { - mesh->points_p0.Append(*starting_mesh->points_p0.At(pcnt)); + mesh->points_p0.Append(*starting_mesh->points_p0.At((int)pcnt)); mesh->iteration_of_insert[pcnt] = starting_mesh->iteration_of_insert[pcnt]; #if 0 if (outer_pts.find(pcnt) == outer_pts.end()) { @@ -363,7 +363,7 @@ #endif } for(f_it = starting_mesh->face_pts.begin(); f_it != starting_mesh->face_pts.end(); f_it++) { - mesh->points_p0.Append(starting_mesh->points_q[(*f_it).first]); + mesh->points_p0.Append(starting_mesh->points_q[(int)(*f_it).first]); mesh->iteration_of_insert[mesh->points_p0.Count()-1] = mesh->iteration_cnt; starting_mesh->index_in_next[(*f_it).first] = mesh->points_p0.Count()-1; } @@ -466,7 +466,7 @@ int b = int(256*drand48() + 1.0); for(f_it = mesh->face_pts.begin(); f_it != mesh->face_pts.end(); f_it++) { l_it = (*f_it).second.begin(); - plot_face(&mesh->points_p0[(*l_it)], &mesh->points_p0[(*(l_it+1))], &mesh->points_p0[(*(l_it+2))], r, g ,b, plot_file); + plot_face(&mesh->points_p0[(int)(*l_it)], &mesh->points_p0[(int)(*(l_it+1))], &mesh->points_p0[(int)(*(l_it+2))], r, g ,b, plot_file); } fclose(plot_file); } @@ -475,7 +475,7 @@ // vertices ON_3dPointArray points_inf; for(size_t v = 0; v < (size_t)mesh->points_p0.Count(); v++) { - points_inf.Append(*mesh->points_p0.At(v)); + points_inf.Append(*mesh->points_p0.At((int)v)); //point_inf(v, mesh, &points_inf); } // The subdivision process shrinks the bot relative to its original @@ -485,14 +485,14 @@ fastf_t scale = 0.0; for(size_t pcnt = 0; pcnt < bot_ip->num_vertices; pcnt++) { ON_3dVector v1(ON_3dPoint(&bot_ip->vertices[pcnt*3])); - ON_3dVector v2(*points_inf.At(pcnt)); + ON_3dVector v2(*points_inf.At((int)pcnt)); scale += 1 + (v1.Length() - v2.Length())/v1.Length(); } scale = scale / bot_ip->num_vertices; for(size_t pcnt = 0; pcnt < (size_t)points_inf.Count(); pcnt++) { - ON_3dPoint p0(*points_inf.At(pcnt)); + ON_3dPoint p0(*points_inf.At((int)pcnt)); ON_3dPoint p1 = p0 * scale; - *points_inf.At(pcnt) = p1; + *points_inf.At((int)pcnt) = p1; } wdbp = wdb_dbopen(dbip, RT_WDB_TYPE_DB_DISK); @@ -500,9 +500,9 @@ fastf_t *vertices = (fastf_t *)bu_malloc(sizeof(fastf_t) * points_inf.Count() * 3, "new verts"); int *faces = (int *)bu_malloc(sizeof(int) * mesh->face_pts.size() * 3, "new faces"); for(size_t v = 0; v < (size_t)points_inf.Count(); v++) { - vertices[v*3] = points_inf[v].x; - vertices[v*3+1] = points_inf[v].y; - vertices[v*3+2] = points_inf[v].z; + vertices[v*3] = points_inf[(int)v].x; + vertices[v*3+1] = points_inf[(int)v].y; + vertices[v*3+2] = points_inf[(int)v].z; } std::map<size_t, std::vector<size_t> >::iterator f_it; std::vector<size_t>::iterator l_it; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54165] brlcad/trunk/src/librt From: <starseeker@us...> - 2013-01-11 20:39 Revision: 54165 http://brlcad.svn.sourceforge.net/brlcad/?rev=54165&view=rev Author: starseeker Date: 2013-01-11 20:38:57 +0000 (Fri, 11 Jan 2013) Log Message: ----------- interpolation of points to create a 3d curve doesn't work so well when there are only two of them. Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt brlcad/trunk/src/librt/test_botpatches.cpp Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2013-01-11 19:59:25 UTC (rev 54164) +++ brlcad/trunk/src/librt/CMakeLists.txt 2013-01-11 20:38:57 UTC (rev 54165) @@ -306,9 +306,9 @@ ${CMAKE_CURRENT_SOURCE_DIR}/../libnurbs ) -#BRLCAD_ADDEXEC(test_botpatches test_botpatches.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) +BRLCAD_ADDEXEC(test_botpatches test_botpatches.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) #BRLCAD_ADDEXEC(test_nurbsfit test_nurbsfit.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) -#BRLCAD_ADDEXEC(test_subdivision test_subdivision.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) +BRLCAD_ADDEXEC(test_subdivision test_subdivision.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) BRLCAD_ADDEXEC(test_dvec test_dvec.cpp "librt" NOSTRICT NO_INSTALL LOCAL) ADD_TEST(test_dvec test_dvec) Modified: brlcad/trunk/src/librt/test_botpatches.cpp =================================================================== --- brlcad/trunk/src/librt/test_botpatches.cpp 2013-01-11 19:59:25 UTC (rev 54164) +++ brlcad/trunk/src/librt/test_botpatches.cpp 2013-01-11 20:38:57 UTC (rev 54165) @@ -759,7 +759,7 @@ face_queue.push(smallest_face); face_groups[info->face_to_plane[face_queue.front()]].erase(face_queue.front()); size_t current_plane = info->face_to_plane[face_queue.front()]; - size_t start_face_num = face_queue.front(); + //size_t start_face_num = face_queue.front(); while (!face_queue.empty()) { size_t face_num = face_queue.front(); face_queue.pop(); @@ -1007,8 +1007,14 @@ ON_3dPoint pt_3d(&info->bot->vertices[(*v_it)]); curve_pnts.Append(pt_3d); } - ON_NurbsCurve *curve_nurb = interpolateLocalCubicCurve(curve_pnts); - int c3i = info->brep->AddEdgeCurve(curve_nurb); + ON_NurbsCurve *curve_nurb; + int c3i; + if (curve_pnts.Count() == 2) { + c3i = info->brep->AddEdgeCurve(new ON_LineCurve(*(curve_pnts.First()), *(curve_pnts.Last()))); + } else { + curve_nurb = interpolateLocalCubicCurve(curve_pnts); + c3i = info->brep->AddEdgeCurve(curve_nurb); + } ON_BrepVertex& StartV = info->brep->m_V[vs_id]; StartV.m_tolerance = 1e-3; ON_BrepVertex& EndV= info->brep->m_V[ve_id]; @@ -1104,8 +1110,6 @@ int vert_prev = -1; //std::cout << "Patch " << patch_id << " loop edges: \n"; bool trim_rev = false; - size_t pullback_failures = 0; - size_t pullback_successes = 0; for(loop_it = loop_edges->begin(); loop_it != loop_edges->end(); loop_it++) { size_t curr_edge = (*loop_it); // Will we need to flip the trim? @@ -1135,8 +1139,10 @@ int prev_trim_rev = 0; int istart = 1; + size_t pullback_failures; if(loop_it == loop_edges->begin()) { - prev_trim_rev = trim_rev; + pullback_failures = 0; + prev_trim_rev = trim_rev; int found_first_pt = 0; while(!found_first_pt && istart < 50) { pt_3d = edge_curve->PointAt(dom.ParameterAt((double)(istart-1)/(double)50)); @@ -1145,10 +1151,14 @@ curve_pnts_2d.Append(pt_2d); loop_anchor = pt_2d; found_first_pt = 1; - } + } else { + istart++; + } } else { + std::cout << "Pullback failure on first pt (" << patch_id << "," << (double)(istart-1)/(double)50 << "): " << pt_3d.x << "," << pt_3d.y << "," << pt_3d.z << "\n"; pullback_failures++; - } + istart++; + } } } else { curve_pnts_2d.Append(pt_2d_prev); @@ -1164,6 +1174,7 @@ pt_2d_prev = pt_2d; } } else { + std::cout << "Pullback failure (" << patch_id << "," << (double)(i)/(double)50 << "): " << pt_3d.x << "," << pt_3d.y << "," << pt_3d.z << "\n"; pullback_failures++; } } @@ -1176,6 +1187,7 @@ pt_2d_prev = pt_2d; } } else { + std::cout << "Pullback failure (" << patch_id << "," << (double)(i)/(double)50 << "): " << pt_3d.x << "," << pt_3d.y << "," << pt_3d.z << "\n"; pullback_failures++; } } @@ -1184,7 +1196,6 @@ if(loop_it+1 == loop_edges->end()) { curve_pnts_2d.Append(loop_anchor); } - if(pullback_failures) std::cout << "Warning: face " << patch_id << " has " << pullback_failures << " pullback failures\n"; //if(trim_rev) {curve_pnts_2d.Reverse();} ON_Curve *trim_curve = interpolateCurve(curve_pnts_2d); int c2i = info->brep->AddTrimCurve(trim_curve); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54224] brlcad/trunk/src/librt From: <n_reed@us...> - 2013-01-29 20:03 Revision: 54224 http://brlcad.svn.sourceforge.net/brlcad/?rev=54224&view=rev Author: n_reed Date: 2013-01-29 20:03:18 +0000 (Tue, 29 Jan 2013) Log Message: ----------- replace pipe draw routine struct parameters & returns with pointer parameters to avoid struct copies Modified Paths: -------------- brlcad/trunk/src/librt/librt_private.h brlcad/trunk/src/librt/primitives/pipe/pipe.c brlcad/trunk/src/librt/primitives/primitive_util.c Modified: brlcad/trunk/src/librt/librt_private.h =================================================================== --- brlcad/trunk/src/librt/librt_private.h 2013-01-29 19:55:10 UTC (rev 54223) +++ brlcad/trunk/src/librt/librt_private.h 2013-01-29 20:03:18 UTC (rev 54224) @@ -117,16 +117,16 @@ extern void ellipse_point_at_radian( point_t result, - vect_t center, - vect_t axis_a, - vect_t axis_b, + const vect_t center, + const vect_t axis_a, + const vect_t axis_b, fastf_t radian); extern void plot_ellipse( struct bu_list *vhead, - vect_t t, - vect_t a, - vect_t b, + const vect_t t, + const vect_t a, + const vect_t b, int num_points); __END_DECLS Modified: brlcad/trunk/src/librt/primitives/pipe/pipe.c =================================================================== --- brlcad/trunk/src/librt/primitives/pipe/pipe.c 2013-01-29 19:55:10 UTC (rev 54223) +++ brlcad/trunk/src/librt/primitives/pipe/pipe.c 2013-01-29 20:03:18 UTC (rev 54224) @@ -1928,12 +1928,12 @@ static int pipe_bend_segments( const struct rt_view_info *info, - struct pipe_bend bend) + const struct pipe_bend *bend) { int num_segments; fastf_t arc_length; - arc_length = (bend.bend_angle / bn_twopi) * bend.bend_circle.radius; + arc_length = (bend->bend_angle / bn_twopi) * bend->bend_circle.radius; num_segments = arc_length / info->point_spacing; if (num_segments < 3) { @@ -2002,15 +2002,15 @@ static void draw_pipe_circle( struct bu_list *vhead, - struct pipe_circle circle, + const struct pipe_circle *circle, int num_segments) { vect_t axis_a, axis_b; - VSCALE(axis_a, circle.orient.v1, circle.radius); - VSCALE(axis_b, circle.orient.v2, circle.radius); + VSCALE(axis_a, circle->orient.v1, circle->radius); + VSCALE(axis_b, circle->orient.v2, circle->radius); - plot_ellipse(vhead, circle.center, axis_a, axis_b, num_segments); + plot_ellipse(vhead, circle->center, axis_a, axis_b, num_segments); } /** @@ -2020,8 +2020,8 @@ static void draw_pipe_parallel_circle_connections( struct bu_list *vhead, - struct pipe_circle start, - struct pipe_circle end, + const struct pipe_circle *start, + const struct pipe_circle *end, int num_lines) { int i; @@ -2033,17 +2033,17 @@ radian_step = bn_twopi / num_lines; - VSCALE(start_a, start.orient.v1, start.radius); - VSCALE(start_b, start.orient.v2, start.radius); - VSCALE(end_a, end.orient.v1, end.radius); - VSCALE(end_b, end.orient.v2, end.radius); + VSCALE(start_a, start->orient.v1, start->radius); + VSCALE(start_b, start->orient.v2, start->radius); + VSCALE(end_a, end->orient.v1, end->radius); + VSCALE(end_b, end->orient.v2, end->radius); radian = 0.0; for (i = 0; i < num_lines; ++i) { - ellipse_point_at_radian(pt, start.center, start_a, start_b, radian); + ellipse_point_at_radian(pt, start->center, start_a, start_b, radian); RT_ADD_VLIST(vhead, pt, BN_VLIST_LINE_MOVE); - ellipse_point_at_radian(pt, end.center, end_a, end_b, radian); + ellipse_point_at_radian(pt, end->center, end_a, end_b, radian); RT_ADD_VLIST(vhead, pt, BN_VLIST_LINE_DRAW); radian += radian_step; @@ -2053,29 +2053,29 @@ static void draw_pipe_connect_points_linearly( struct bu_list *vhead, - struct wdb_pipept startpt, - struct wdb_pipept endpt, - struct pipe_orientation orient, + const struct wdb_pipept *startpt, + const struct wdb_pipept *endpt, + const struct pipe_orientation *orient, int num_connections) { struct pipe_circle start_circle, end_circle; - start_circle.orient = end_circle.orient = orient; + start_circle.orient = end_circle.orient = *orient; /* struct copy */ - VMOVE(start_circle.center, startpt.pp_coord); - VMOVE(end_circle.center, endpt.pp_coord); + VMOVE(start_circle.center, startpt->pp_coord); + VMOVE(end_circle.center, endpt->pp_coord); /* connect outer circles */ - start_circle.radius = startpt.pp_od / 2.0; - end_circle.radius = endpt.pp_od / 2.0; - draw_pipe_parallel_circle_connections(vhead, start_circle, end_circle, + start_circle.radius = startpt->pp_od / 2.0; + end_circle.radius = endpt->pp_od / 2.0; + draw_pipe_parallel_circle_connections(vhead, &start_circle, &end_circle, num_connections); /* connect inner circles */ - if (startpt.pp_id > 0.0 && endpt.pp_id > 0.0) { - start_circle.radius = startpt.pp_id / 2.0; - end_circle.radius = endpt.pp_id / 2.0; - draw_pipe_parallel_circle_connections(vhead, start_circle, end_circle, + if (startpt->pp_id > 0.0 && endpt->pp_id > 0.0) { + start_circle.radius = startpt->pp_id / 2.0; + end_circle.radius = endpt->pp_id / 2.0; + draw_pipe_parallel_circle_connections(vhead, &start_circle, &end_circle, num_connections); } } @@ -2091,7 +2091,7 @@ startpt = *BU_LIST_PREV(wdb_pipept, &seg->cur->l); VMOVE(startpt.pp_coord, seg->last_drawn); - draw_pipe_connect_points_linearly(vhead, startpt, endpt, seg->orient, + draw_pipe_connect_points_linearly(vhead, &startpt, &endpt, &seg->orient, seg->connecting_arcs); VMOVE(seg->last_drawn, endpt.pp_coord); @@ -2138,17 +2138,16 @@ } } -static struct pipe_bend -pipe_seg_bend(const struct pipe_segment *seg) +static void +pipe_seg_bend(struct pipe_bend *out_bend, const struct pipe_segment *seg) { - struct pipe_bend bend; fastf_t dist_to_bend_end; vect_t cur_to_prev, cur_to_next; struct wdb_pipept *prevpt, *curpt, *nextpt; - bend.pipe_circle.orient = seg->orient; - bend.bend_angle = pipe_seg_bend_angle(seg); - pipe_seg_bend_normal(bend.bend_normal, seg); + out_bend->pipe_circle.orient = seg->orient; + out_bend->bend_angle = pipe_seg_bend_angle(seg); + pipe_seg_bend_normal(out_bend->bend_normal, seg); curpt = seg->cur; prevpt = BU_LIST_PREV(wdb_pipept, &curpt->l); @@ -2160,24 +2159,21 @@ VUNITIZE(cur_to_next); dist_to_bend_end = pipe_seg_dist_to_bend_endpoint(seg); - VJOIN1(bend.bend_start, curpt->pp_coord, dist_to_bend_end, cur_to_prev); - VJOIN1(bend.bend_end, curpt->pp_coord, dist_to_bend_end, cur_to_next); + VJOIN1(out_bend->bend_start, curpt->pp_coord, dist_to_bend_end, cur_to_prev); + VJOIN1(out_bend->bend_end, curpt->pp_coord, dist_to_bend_end, cur_to_next); - bend.bend_circle.radius = curpt->pp_bendradius; - VCROSS(bend.bend_circle.orient.v1, cur_to_prev, bend.bend_normal); - VCROSS(bend.bend_circle.orient.v2, bend.bend_circle.orient.v1, - bend.bend_normal); - VJOIN1(bend.bend_circle.center, bend.bend_start, -bend.bend_circle.radius, - bend.bend_circle.orient.v1); - - - return bend; + out_bend->bend_circle.radius = curpt->pp_bendradius; + VCROSS(out_bend->bend_circle.orient.v1, cur_to_prev, out_bend->bend_normal); + VCROSS(out_bend->bend_circle.orient.v2, out_bend->bend_circle.orient.v1, + out_bend->bend_normal); + VJOIN1(out_bend->bend_circle.center, out_bend->bend_start, -out_bend->bend_circle.radius, + out_bend->bend_circle.orient.v1); } static struct pipe_orientation draw_pipe_connect_circular_segs( struct bu_list *vhead, - struct pipe_bend bend, + const struct pipe_bend *bend, int num_arcs, int segs_per_arc) { @@ -2193,23 +2189,23 @@ BU_CK_LIST_HEAD(vhead); /* short names */ - VMOVE(bend_center, bend.bend_circle.center); - VMOVE(bend_norm, bend.bend_normal); - VMOVE(bend_start, bend.bend_start); - VMOVE(bend_end, bend.bend_end); + VMOVE(bend_center, bend->bend_circle.center); + VMOVE(bend_norm, bend->bend_normal); + VMOVE(bend_start, bend->bend_start); + VMOVE(bend_end, bend->bend_end); - pipe_radius = bend.pipe_circle.radius; - VSCALE(pipe_axis_a, bend.pipe_circle.orient.v1, pipe_radius); - VSCALE(pipe_axis_b, bend.pipe_circle.orient.v2, pipe_radius); + pipe_radius = bend->pipe_circle.radius; + VSCALE(pipe_axis_a, bend->pipe_circle.orient.v1, pipe_radius); + VSCALE(pipe_axis_b, bend->pipe_circle.orient.v2, pipe_radius); /* calculate matrix to rotate vectors around the bend */ { vect_t reverse_norm; VREVERSE(reverse_norm, bend_norm); - bn_mat_arb_rot(rot_mat, bend_center, reverse_norm, bend.bend_angle); + bn_mat_arb_rot(rot_mat, bend_center, reverse_norm, bend->bend_angle); } - arc_circle.orient = bend.bend_circle.orient; + arc_circle.orient = bend->bend_circle.orient; radian_step = bn_twopi / num_arcs; radian = 0.0; @@ -2242,10 +2238,10 @@ } /* return the final orientation of the pipe circle */ - MAT4X3VEC(end_pipe_r, rot_mat, bend.pipe_circle.orient.v1); + MAT4X3VEC(end_pipe_r, rot_mat, bend->pipe_circle.orient.v1); VMOVE(end_orient.v1, end_pipe_r); - MAT4X3VEC(end_pipe_r, rot_mat, bend.pipe_circle.orient.v2); + MAT4X3VEC(end_pipe_r, rot_mat, bend->pipe_circle.orient.v2); VMOVE(end_orient.v2, end_pipe_r); return end_orient; @@ -2257,7 +2253,7 @@ struct pipe_bend bend; struct wdb_pipept *prevpt, *curpt, startpt, endpt; - bend = pipe_seg_bend(seg); + pipe_seg_bend(&bend, seg); curpt = seg->cur; prevpt = BU_LIST_PREV(wdb_pipept, &curpt->l); @@ -2268,19 +2264,19 @@ VMOVE(startpt.pp_coord, seg->last_drawn); VMOVE(endpt.pp_coord, bend.bend_start); - draw_pipe_connect_points_linearly(vhead, startpt, endpt, seg->orient, + draw_pipe_connect_points_linearly(vhead, &startpt, &endpt, &seg->orient, PIPE_CONNECTING_ARCS); VMOVE(seg->last_drawn, bend.bend_start); /* draw circular bend */ bend.pipe_circle.radius = curpt->pp_od / 2.0; - seg->orient = draw_pipe_connect_circular_segs(vhead, bend, + seg->orient = draw_pipe_connect_circular_segs(vhead, &bend, PIPE_CONNECTING_ARCS, PIPE_CIRCLE_SEGS); if (prevpt->pp_id > 0.0 && curpt->pp_id > 0.0) { bend.pipe_circle.radius = curpt->pp_id / 2.0; - seg->orient = draw_pipe_connect_circular_segs(vhead, bend, + seg->orient = draw_pipe_connect_circular_segs(vhead, &bend, PIPE_CONNECTING_ARCS, PIPE_CIRCLE_SEGS); } @@ -2297,7 +2293,7 @@ struct pipe_bend bend; struct wdb_pipept *prevpt, *curpt, startpt, endpt; - bend = pipe_seg_bend(seg); + pipe_seg_bend(&bend, seg); curpt = seg->cur; prevpt = BU_LIST_PREV(wdb_pipept, &curpt->l); @@ -2308,21 +2304,21 @@ VMOVE(startpt.pp_coord, seg->last_drawn); VMOVE(endpt.pp_coord, bend.bend_start); - draw_pipe_connect_points_linearly(vhead, startpt, endpt, seg->orient, + draw_pipe_connect_points_linearly(vhead, &startpt, &endpt, &seg->orient, seg->connecting_arcs); VMOVE(seg->last_drawn, bend.bend_start); /* draw circular bend */ bend.pipe_circle.radius = curpt->pp_od / 2.0; - num_segments = pipe_bend_segments(info, bend); - seg->orient = draw_pipe_connect_circular_segs(vhead, bend, + num_segments = pipe_bend_segments(info, &bend); + seg->orient = draw_pipe_connect_circular_segs(vhead, &bend, seg->connecting_arcs, num_segments); if (prevpt->pp_id > 0.0 && curpt->pp_id > 0.0) { bend.pipe_circle.radius = curpt->pp_id / 2.0; - num_segments = pipe_bend_segments(info, bend); - seg->orient = draw_pipe_connect_circular_segs(vhead, bend, + num_segments = pipe_bend_segments(info, &bend); + seg->orient = draw_pipe_connect_circular_segs(vhead, &bend, seg->connecting_arcs, num_segments); } @@ -2343,12 +2339,12 @@ /* draw outer circle */ pipe_circle.radius = endpt->pp_od / 2.0; - draw_pipe_circle(vhead, pipe_circle, PIPE_CIRCLE_SEGS); + draw_pipe_circle(vhead, &pipe_circle, PIPE_CIRCLE_SEGS); /* draw inner circle */ if (endpt->pp_id > 0.0) { pipe_circle.radius = endpt->pp_id / 2.0; - draw_pipe_circle(vhead, pipe_circle, PIPE_CIRCLE_SEGS); + draw_pipe_circle(vhead, &pipe_circle, PIPE_CIRCLE_SEGS); } VMOVE(seg->last_drawn, endpt->pp_coord); @@ -2372,13 +2368,13 @@ /* draw outer circle */ pipe_circle.radius = endpt->pp_od / 2.0; num_segments = pipe_circle_segments(info, pipe_circle.radius); - draw_pipe_circle(vhead, pipe_circle, num_segments); + draw_pipe_circle(vhead, &pipe_circle, num_segments); /* draw inner circle */ if (endpt->pp_id > 0.0) { pipe_circle.radius = endpt->pp_id / 2.0; num_segments = pipe_circle_segments(info, pipe_circle.radius); - draw_pipe_circle(vhead, pipe_circle, num_segments); + draw_pipe_circle(vhead, &pipe_circle, num_segments); } VMOVE(seg->last_drawn, endpt->pp_coord); Modified: brlcad/trunk/src/librt/primitives/primitive_util.c =================================================================== --- brlcad/trunk/src/librt/primitives/primitive_util.c 2013-01-29 19:55:10 UTC (rev 54223) +++ brlcad/trunk/src/librt/primitives/primitive_util.c 2013-01-29 20:03:18 UTC (rev 54224) @@ -340,9 +340,9 @@ void ellipse_point_at_radian( point_t result, - vect_t center, - vect_t axis_a, - vect_t axis_b, + const vect_t center, + const vect_t axis_a, + const vect_t axis_b, fastf_t radian) { fastf_t cos_rad, sin_rad; @@ -356,9 +356,9 @@ void plot_ellipse( struct bu_list *vhead, - vect_t center, - vect_t axis_a, - vect_t axis_b, + const vect_t center, + const vect_t axis_a, + const vect_t axis_b, int num_points) { int i; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54235] brlcad/trunk/src/librt From: <carlmoore@us...> - 2013-01-30 18:50 Revision: 54235 http://brlcad.svn.sourceforge.net/brlcad/?rev=54235&view=rev Author: carlmoore Date: 2013-01-30 18:50:03 +0000 (Wed, 30 Jan 2013) Log Message: ----------- use %ld to fix warnings about expecting int but getting long int Modified Paths: -------------- brlcad/trunk/src/librt/comb/db_comb.c brlcad/trunk/src/librt/db5_types.c Modified: brlcad/trunk/src/librt/comb/db_comb.c =================================================================== --- brlcad/trunk/src/librt/comb/db_comb.c 2013-01-30 18:10:25 UTC (rev 54234) +++ brlcad/trunk/src/librt/comb/db_comb.c 2013-01-30 18:50:03 UTC (rev 54235) @@ -388,7 +388,7 @@ comb->inherit = (rp[0].c.c_inherit == DB_INH_HIGHER) ? 1 : 0; /* Automatic material table lookup here? */ if (comb->region_flag) - bu_vls_printf(&comb->material, "gift%d", comb->GIFTmater); + bu_vls_printf(&comb->material, "gift%ld", comb->GIFTmater); if (rt_tree_array) bu_free((genptr_t)rt_tree_array, "rt_tree_array"); @@ -793,7 +793,7 @@ if (comb->region_flag) { bu_vls_printf(str, - "REGION id=%d (air=%d, los=%d, GIFTmater=%d) ", + "REGION id=%ld (air=%ld, los=%ld, GIFTmater=%ld) ", comb->region_id, comb->aircode, comb->los, Modified: brlcad/trunk/src/librt/db5_types.c =================================================================== --- brlcad/trunk/src/librt/db5_types.c 2013-01-30 18:10:25 UTC (rev 54234) +++ brlcad/trunk/src/librt/db5_types.c 2013-01-30 18:50:03 UTC (rev 54235) @@ -541,7 +541,7 @@ if (endptr == bu_vls_addr(&newval) + strlen(bu_vls_addr(&newval))) { comb->region_id = attr_num_val; } else { - bu_log("WARNING: [%s] has invalid region_id value [%s]\nregion_id remains at %d\n", name, bu_vls_addr(&newval), comb->region_id); + bu_log("WARNING: [%s] has invalid region_id value [%s]\nregion_id remains at %ld\n", name, bu_vls_addr(&newval), comb->region_id); } } else { /* remove region_id */ @@ -556,7 +556,7 @@ if (endptr == bu_vls_addr(&newval) + strlen(bu_vls_addr(&newval))) { comb->GIFTmater = attr_num_val; } else { - bu_log("WARNING: [%s] has invalid material_id value [%s]\nmateriel_id remains at %d\n", name, bu_vls_addr(&newval), comb->GIFTmater); + bu_log("WARNING: [%s] has invalid material_id value [%s]\nmateriel_id remains at %ld\n", name, bu_vls_addr(&newval), comb->GIFTmater); } } else { /* empty - set to zero */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54240] brlcad/trunk/src/librt From: <starseeker@us...> - 2013-01-30 23:02 Revision: 54240 http://brlcad.svn.sourceforge.net/brlcad/?rev=54240&view=rev Author: starseeker Date: 2013-01-30 23:02:46 +0000 (Wed, 30 Jan 2013) Log Message: ----------- Rename some test files Added Paths: ----------- brlcad/trunk/src/librt/test_bot2nurbs.cpp brlcad/trunk/src/librt/test_root3-subd.cpp Removed Paths: ------------- brlcad/trunk/src/librt/test_botpatches.cpp brlcad/trunk/src/librt/test_subdivision.cpp Copied: brlcad/trunk/src/librt/test_bot2nurbs.cpp (from rev 54196, brlcad/trunk/src/librt/test_botpatches.cpp) =================================================================== --- brlcad/trunk/src/librt/test_bot2nurbs.cpp (rev 0) +++ brlcad/trunk/src/librt/test_bot2nurbs.cpp 2013-01-30 23:02:46 UTC (rev 54240) @@ -0,0 +1,1606 @@ +/* TODO - Can't keep shifting the fitting plane for a triangle patch + * every time a triangle is added - too computationally expensive. + * Instead, need to make sure that the starting plane used for the + * NURBS fit is the same plane being used for the triangle overlap + * testing. Hopefully, that will preclude any "vertical or worse" + * surface fit issues while still allowing for a good surface fit, + * and avoid this business of triangles that overlap in one fit + * plane but not in another. Will probably need a change or two + * in the PCL surface fitting code.*/ + + +#include "common.h" + +#include <map> +#include <set> +#include <queue> +#include <list> +#include <vector> +#include <iostream> +#include <fstream> + +#include "vmath.h" +#include "raytrace.h" +#include "wdb.h" +#include "plot3.h" +#include "opennurbs.h" +#include "opennurbs_fit.h" +#include <Eigen/SVD> +#include "nurbs.h" + +typedef std::pair<size_t, size_t> Edge; +typedef std::map< size_t, std::set<Edge> > VertToEdge; +typedef std::map< size_t, std::set<size_t> > VertToPatch; +typedef std::map< Edge, std::set<size_t> > EdgeToPatch; +typedef std::map< Edge, std::set<size_t> > EdgeToFace; +typedef std::map< size_t, size_t > FaceToPatch; +typedef std::map< size_t, size_t > PatchToPlane; +typedef std::set<Edge> EdgeList; +typedef std::set<size_t> FaceList; + +struct Manifold_Info { + ON_Brep *brep; + ON_Brep *brep2; + struct rt_bot_internal *bot; + + std::map< size_t, std::set<size_t> > patches; + std::map< size_t, std::set<size_t> > patch_edges; + std::map< size_t, std::vector<size_t> > polycurves; + + VertToEdge vert_to_edge; + VertToPatch vert_to_patch; + EdgeToFace edge_to_face; + EdgeToPatch edge_to_patch; + FaceToPatch face_to_patch; + std::map< size_t, size_t > face_to_plane; + PatchToPlane patch_to_plane; + ON_3dVectorArray face_normals; + ON_3dVectorArray vectors; + std::map< std::pair<size_t, size_t>, fastf_t > norm_results; + size_t patch_size_threshold; + double face_plane_parallel_threshold; + double neighbor_angle_threshold; + int patch_cnt; +}; + +/********************************************************************************** + * + * Utility functions used throughout the process of fitting + * + **********************************************************************************/ + +// Make an edge using consistent vertex ordering +Edge mk_edge(size_t pt_A, size_t pt_B) +{ + if (pt_A <= pt_B) { + return std::make_pair(pt_A, pt_B); + } else { + return std::make_pair(pt_B, pt_A); + } +} + +// Calculate area of a face +double face_area(struct rt_bot_internal *bot, size_t face_num) +{ + point_t ptA, ptB, ptC; + double a, b, c, p; + double area; + VMOVE(ptA, &bot->vertices[bot->faces[face_num*3+0]*3]); + VMOVE(ptB, &bot->vertices[bot->faces[face_num*3+1]*3]); + VMOVE(ptC, &bot->vertices[bot->faces[face_num*3+2]*3]); + a = DIST_PT_PT(ptA, ptB); + b = DIST_PT_PT(ptB, ptC); + c = DIST_PT_PT(ptC, ptA); + p = (a + b + c)/2; + area = sqrt(p*(p-a)*(p-b)*(p-c)); + return area; +} + +// Given a patch consisting of a set of faces find the +// set of edges that forms the outer edge of the patch +void find_edge_segments(std::set<size_t> *faces, EdgeList *patch_edges, struct Manifold_Info *info) +{ + size_t pt_A, pt_B, pt_C; + std::set<size_t>::iterator it; + std::map<std::pair<size_t, size_t>, size_t> edge_face_cnt; + std::map<std::pair<size_t, size_t>, size_t>::iterator efc_it; + patch_edges->clear(); + for (it = faces->begin(); it != faces->end(); it++) { + pt_A = info->bot->faces[(*it)*3+0]*3; + pt_B = info->bot->faces[(*it)*3+1]*3; + pt_C = info->bot->faces[(*it)*3+2]*3; + edge_face_cnt[mk_edge(pt_A, pt_B)] += 1; + edge_face_cnt[mk_edge(pt_B, pt_C)] += 1; + edge_face_cnt[mk_edge(pt_C, pt_A)] += 1; + } + + for (efc_it = edge_face_cnt.begin(); efc_it!=edge_face_cnt.end(); efc_it++) { + if ((*efc_it).second == 1) { + info->vert_to_edge[(*efc_it).first.first].insert((*efc_it).first); + info->vert_to_edge[(*efc_it).first.second].insert((*efc_it).first); + patch_edges->insert((*efc_it).first); + } + } +} + +// Given a BoT face, return the three edges associated with that face +void get_face_edges(struct rt_bot_internal *bot, size_t face_num, std::set<Edge> *face_edges) +{ + size_t pt_A, pt_B, pt_C; + pt_A = bot->faces[face_num*3+0]*3; + pt_B = bot->faces[face_num*3+1]*3; + pt_C = bot->faces[face_num*3+2]*3; + face_edges->insert(mk_edge(pt_A, pt_B)); + face_edges->insert(mk_edge(pt_B, pt_C)); + face_edges->insert(mk_edge(pt_C, pt_A)); +} + +// Given a BoT face, return the three other faces that share an edge with that face +void get_connected_faces(struct rt_bot_internal *bot, size_t face_num, EdgeToFace *edge_to_face, std::set<size_t> *faces) +{ + std::set<Edge> face_edges; + std::set<Edge>::iterator face_edges_it; + get_face_edges(bot, face_num, &face_edges); + for (face_edges_it = face_edges.begin(); face_edges_it != face_edges.end(); face_edges_it++) { + std::set<size_t> faces_from_edge = (*edge_to_face)[(*face_edges_it)]; + std::set<size_t>::iterator ffe_it; + for (ffe_it = faces_from_edge.begin(); ffe_it != faces_from_edge.end() ; ffe_it++) { + if ((*ffe_it) != face_num) { + faces->insert((*ffe_it)); + } + } + } +} + + +// Use SVD algorithm from Soderkvist to fit a plane to vertex points +// http://www.math.ltu.se/~jove/courses/mam208/svd.pdf +void fit_plane(size_t UNUSED(patch_id), std::set<size_t> *faces, struct Manifold_Info *info, ON_Plane *plane) { + if (faces->size() > 0) { + ON_3dPoint center(0.0, 0.0, 0.0); + std::set<size_t> verts; + std::set<size_t>::iterator f_it, v_it; + for(f_it = faces->begin(); f_it != faces->end(); f_it++) { + verts.insert(info->bot->faces[(*f_it)*3+0]*3); + verts.insert(info->bot->faces[(*f_it)*3+1]*3); + verts.insert(info->bot->faces[(*f_it)*3+2]*3); + } + point_t pt; + for(v_it = verts.begin(); v_it != verts.end(); v_it++) { + VMOVE(pt, &info->bot->vertices[*v_it]); + center.x += pt[0]/verts.size(); + center.y += pt[1]/verts.size(); + center.z += pt[2]/verts.size(); + } + Eigen::MatrixXd A(3, verts.size()); + int vert_cnt = 0; + for(v_it = verts.begin(); v_it != verts.end(); v_it++) { + VMOVE(pt, &info->bot->vertices[*v_it]); + A(0,vert_cnt) = pt[0] - center.x; + A(1,vert_cnt) = pt[1] - center.y; + A(2,vert_cnt) = pt[2] - center.z; + vert_cnt++; + } + + Eigen::JacobiSVD<Eigen::MatrixXd> svd(A, Eigen::ComputeThinU); + + // 4. Normal is in column 3 of U matrix + ON_3dVector normal(svd.matrixU()(0,2), svd.matrixU()(1,2), svd.matrixU()(2,2)); + + // 5. Construct plane + ON_Plane new_plane(center, normal); + (*plane) = new_plane; +#if 0 + struct bu_vls name; + bu_vls_init(&name); + bu_vls_printf(&name, "fit_plane_%d.pl", patch_id); + FILE* plot_file = fopen(bu_vls_addr(&name), "w"); + int r = int(256*drand48() + 1.0); + int g = int(256*drand48() + 1.0); + int b = int(256*drand48() + 1.0); + point_t pc; + for(f_it = faces->begin(); f_it != faces->end(); f_it++) { + point_t p1, p2, p3; + VMOVE(p1, &info->bot->vertices[info->bot->faces[(*f_it)*3+0]*3]); + VMOVE(p2, &info->bot->vertices[info->bot->faces[(*f_it)*3+1]*3]); + VMOVE(p3, &info->bot->vertices[info->bot->faces[(*f_it)*3+2]*3]); + VSUB2(p1, p1, pc); + VSUB2(p2, p2, pc); + VSUB2(p3, p3, pc); + pdv_3move(plot_file, p1); + pdv_3cont(plot_file, p2); + pdv_3move(plot_file, p1); + pdv_3cont(plot_file, p3); + pdv_3move(plot_file, p2); + pdv_3cont(plot_file, p3); + } + pl_color(plot_file, 255, 255, 255); + point_t pn; + VSET(pc, center.x,center.y,center.z); + pdv_3move(plot_file, pc); + VSET(pn, normal.x,normal.y,normal.z); + VSCALE(pn, pn, 200); + VADD2(pn,pn,pc); + pdv_3cont(plot_file, pn); + + fclose(plot_file); +#endif + } +} + +// Check if a mesh is planar +int planar_patch_test(size_t patch_id, std::set<size_t> *faces, struct Manifold_Info *info, fastf_t tol) { + if (faces->size() == 1) return 1; + if (faces->size() > 0) { + std::set<size_t> verts; + std::set<size_t>::iterator f_it, v_it; + fastf_t max_dist = 0.0; + ON_Plane best_fit_plane; + fit_plane(patch_id, faces, info, &best_fit_plane); + for(f_it = faces->begin(); f_it != faces->end(); f_it++) { + verts.insert(info->bot->faces[(*f_it)*3+0]*3); + verts.insert(info->bot->faces[(*f_it)*3+1]*3); + verts.insert(info->bot->faces[(*f_it)*3+2]*3); + } + for(v_it = verts.begin(); v_it != verts.end(); v_it++) { + point_t pt; + VMOVE(pt, &info->bot->vertices[*v_it]); + fastf_t curr_dist = best_fit_plane.DistanceTo(ON_3dPoint(pt[0], pt[1], pt[2])); + if (curr_dist > max_dist) max_dist = curr_dist; + } + if (max_dist < tol) return 1; + return 0; + } else { + return 0; + } +} +/********************************************************************************** + * + * Debugging code for plotting structures commonly generated during fitting + * + **********************************************************************************/ + +// To plot specific groups of curves in MGED, do the following: +// set glob_compat_mode 0 +// set pl_list [glob 27_curve*.pl] +// foreach plfile $pl_list {overlay $plfile} +void plot_curve(struct rt_bot_internal *bot, std::vector<size_t> *pts, int r, int g, int b, FILE *c_plot) +{ + if (c_plot == NULL) { + FILE* plot = fopen("plot_curve.pl", "w"); + pl_color(plot, int(256*drand48() + 1.0), int(256*drand48() + 1.0), int(256*drand48() + 1.0)); + std::vector<size_t>::iterator v_it; + for (v_it = pts->begin(); v_it != pts->end()-1; v_it++) { + pdv_3move(plot, &bot->vertices[(*v_it)]); + pdv_3cont(plot, &bot->vertices[(*(v_it+1))]); + } + fclose(plot); + } else { + pl_color(c_plot, r, g, b); + std::vector<size_t>::iterator v_it; + for (v_it = pts->begin(); v_it != pts->end()-1; v_it++) { + pdv_3move(c_plot, &bot->vertices[(*v_it)]); + pdv_3cont(c_plot, &bot->vertices[(*(v_it+1))]); + } + } +} + +void plot_face(point_t p1, point_t p2, point_t p3, int r, int g, int b, FILE *c_plot) +{ + pl_color(c_plot, r, g, b); + pdv_3move(c_plot, p1); + pdv_3cont(c_plot, p2); + pdv_3move(c_plot, p1); + pdv_3cont(c_plot, p3); + pdv_3move(c_plot, p2); + pdv_3cont(c_plot, p3); +} + +void plot_faces(std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info, const char *filename) +{ + std::map< size_t, std::set<size_t> >::iterator p_it; + FILE* plot_file = fopen(filename, "w"); + for (p_it = patches->begin(); p_it != patches->end(); p_it++) { + int r = int(256*drand48() + 1.0); + int g = int(256*drand48() + 1.0); + int b = int(256*drand48() + 1.0); + std::set<size_t> *faces = &((*p_it).second); + std::set<size_t>::iterator f_it; + for (f_it = faces->begin(); f_it != faces->end(); f_it++) { + plot_face(&info->bot->vertices[info->bot->faces[(*f_it)*3+0]*3], &info->bot->vertices[info->bot->faces[(*f_it)*3+1]*3], &info->bot->vertices[info->bot->faces[(*f_it)*3+2]*3], r, g ,b, plot_file); + } + } + fclose(plot_file); +} + +void plot_patch_borders(std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info, const char *filename) +{ + std::map< size_t, std::set<size_t> >::iterator p_it; + FILE* edge_plot = fopen(filename, "w"); + pl_color(edge_plot, 255, 255, 255); + for (p_it = patches->begin(); p_it != patches->end(); p_it++) { + EdgeList patch_edges; + EdgeList::iterator e_it; + find_edge_segments(&((*p_it).second), &patch_edges, info); + for (e_it = patch_edges.begin(); e_it != patch_edges.end(); e_it++) { + pdv_3move(edge_plot, &info->bot->vertices[(*e_it).first]); + pdv_3cont(edge_plot, &info->bot->vertices[(*e_it).second]); + } + } + fclose(edge_plot); +} + +void plot_ncurve(ON_Curve &curve, FILE *c_plot) +{ + double pt1[3], pt2[3]; + ON_2dPoint from, to; + int plotres = 100; + if (curve.IsLinear()) { + int knotcnt = curve.SpanCount(); + double *knots = new double[knotcnt + 1]; + + curve.GetSpanVector(knots); + for (int i = 1; i <= knotcnt; i++) { + ON_3dPoint p = curve.PointAt(knots[i - 1]); + VMOVE(pt1, p); + p = curve.PointAt(knots[i]); + VMOVE(pt2, p); + pdv_3move(c_plot, pt1); + pdv_3cont(c_plot, pt2); + } + + } else { + ON_Interval dom = curve.Domain(); + // XXX todo: dynamically sample the curve + for (int i = 1; i <= plotres; i++) { + ON_3dPoint p = curve.PointAt(dom.ParameterAt((double)(i - 1) + / (double)plotres)); + VMOVE(pt1, p); + p = curve.PointAt(dom.ParameterAt((double) i / (double)plotres)); + VMOVE(pt2, p); + pdv_3move(c_plot, pt1); + pdv_3cont(c_plot, pt2); + } + } +} + +// plot loop +void plot_loop(std::vector<size_t> *edges, struct Manifold_Info *info, FILE *l_plot) +{ + std::vector<size_t>::iterator v_it; + int r = int(256*drand48() + 1.0); + int g = int(256*drand48() + 1.0); + int b = int(256*drand48() + 1.0); + for (v_it = edges->begin(); v_it != edges->end(); v_it++) { + pl_color(l_plot, r, g, b); + ON_BrepEdge& edge = info->brep->m_E[(int)(*v_it)]; + const ON_Curve* edge_curve = edge.EdgeCurveOf(); + ON_Interval dom = edge_curve->Domain(); + // XXX todo: dynamically sample the curve + int plotres = 50; + for (int i = 1; i <= plotres; i++) { + double pt1[3], pt2[3]; + ON_3dPoint p = edge_curve->PointAt(dom.ParameterAt((double)(i - 1) + / (double)plotres)); + VMOVE(pt1, p); + p = edge_curve->PointAt(dom.ParameterAt((double) i / (double)plotres)); + VMOVE(pt2, p); + pdv_3move(l_plot, pt1); + pdv_3cont(l_plot, pt2); + } + } +} + +/********************************************************************************** + * + * Code for partitioning a mesh into patches suitable for NURBS surface fitting + * + **********************************************************************************/ + +// Clean out empty patches +void remove_empty_patches(struct Manifold_Info *info) +{ + for (int i = 0; i < (int)info->patches.size(); i++) { + if (info->patches[i].size() == 0) { + info->patches.erase(i); + } + } +} + + +void sync_structure_maps(struct Manifold_Info *info) +{ + std::map< size_t, std::set<size_t> >::iterator p_it; + info->edge_to_patch.clear(); + info->vert_to_patch.clear(); + info->face_to_patch.clear(); + for (p_it = info->patches.begin(); p_it != info->patches.end(); p_it++) { + std::set<size_t>::iterator f_it; + std::set<size_t> *faces = &((*p_it).second); + for (f_it = faces->begin(); f_it != faces->end(); f_it++) { + info->face_to_patch[(*f_it)] = (*p_it).first; + std::set<Edge> face_edges; + std::set<Edge>::iterator face_edges_it; + get_face_edges(info->bot, (*f_it), &face_edges); + for (face_edges_it = face_edges.begin(); face_edges_it != face_edges.end(); face_edges_it++) { + info->edge_to_patch[(*face_edges_it)].insert((*p_it).first); + info->vert_to_patch[(*face_edges_it).first].insert((*p_it).first); + info->vert_to_patch[(*face_edges_it).second].insert((*p_it).first); + } + } + info->patch_to_plane[(*p_it).first] = info->face_to_plane[*(faces->begin())]; + } +} + +// For a given face, determine which patch shares the majority of its edges. If no one patch +// has a majority, return -1 +int find_major_patch(size_t face_num, struct Manifold_Info *info, size_t curr_patch, size_t patch_count) +{ + std::map<size_t, size_t> patch_cnt; + std::map<size_t, size_t>::iterator patch_cnt_itr; + std::set<size_t> connected_faces; + std::set<size_t>::iterator cf_it; + size_t max_patch = 0; + size_t max_patch_edge_cnt = 0; + get_connected_faces(info->bot, face_num, &(info->edge_to_face), &connected_faces); + for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { + patch_cnt[info->face_to_patch[*cf_it]] += 1; + } + for (patch_cnt_itr = patch_cnt.begin(); patch_cnt_itr != patch_cnt.end() ; patch_cnt_itr++) { + if ((*patch_cnt_itr).second > max_patch_edge_cnt) { + max_patch_edge_cnt = (*patch_cnt_itr).second; + max_patch = (*patch_cnt_itr).first; + } + } + if (max_patch_edge_cnt == 1) { + if (patch_count > 3) { + return -1; + } else { + // A patch with three or fewer triangles is considered a small patch - if one of the shared + // faces is a viable candidate, return it. + int candidate_patch = -1; + double candidate_patch_norm = 0; + for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { + if (info->face_to_patch[*cf_it] != curr_patch) { + double current_norm = info->norm_results[std::make_pair(face_num, info->patch_to_plane[info->face_to_patch[(*cf_it)]])]; + if (current_norm > candidate_patch_norm) { + candidate_patch = info->face_to_patch[(*cf_it)]; + candidate_patch_norm = current_norm; + } + } + } + return candidate_patch; + } + } else { + return (int)max_patch; + } +} + +// Given a list of edges and the "current" patch, find triangles that share more edges with +// a different patch. If the corresponding normals allow, move the triangles in question to +// the patch with which they share the most edges. Return the number of triangles shifted. +// This won't fully "smooth" an edge in a given pass, but an iterative approach should converge +// to edges with triangles in their correct "major" patches +size_t shift_edge_triangles(std::map< size_t, std::set<size_t> > *patches, size_t curr_patch, struct Manifold_Info *info) +{ + std::set<size_t> patch_edgefaces; + std::map<size_t, size_t> faces_to_shift; + std::map<size_t, size_t>::iterator f_it; + EdgeList edges; + EdgeList::iterator e_it; + std::set<size_t>::iterator sizet_it; + + // 0. Build edge set; + find_edge_segments(&((*patches)[curr_patch]), &edges, info); + + // 1. build triangle set of edge triangles in patch. + for (e_it = edges.begin(); e_it != edges.end(); e_it++) { + std::set<size_t> faces_from_edge = info->edge_to_face[(*e_it)]; + for (sizet_it = faces_from_edge.begin(); sizet_it != faces_from_edge.end() ; sizet_it++) { + if (info->face_to_patch[(*sizet_it)] == curr_patch) { + patch_edgefaces.insert((*sizet_it)); + } + } + + } + // 2. build triangle set of edge triangles with major patch other than current patch + // and a normal that permits movement to the major patch + for (sizet_it = patch_edgefaces.begin(); sizet_it != patch_edgefaces.end() ; sizet_it++) { + int major_patch = find_major_patch((*sizet_it), info, curr_patch, (*patches)[curr_patch].size()); + if (major_patch != (int)curr_patch && major_patch != -1) { + if (info->norm_results[std::make_pair((*sizet_it), info->patch_to_plane[major_patch])] >= 0) { + faces_to_shift[(*sizet_it)] = major_patch; + } + } + } + + // 3. move triangles to their major patch. + for (f_it = faces_to_shift.begin(); f_it != faces_to_shift.end(); f_it++) { + (*patches)[info->face_to_patch[(*f_it).first]].erase((*f_it).first); + (*patches)[(*f_it).second].insert((*f_it).first); + info->face_to_patch[(*f_it).first] = (*f_it).second; + } + + return faces_to_shift.size(); +} + +void construct_patches(std::set<size_t> *faces, std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info) { + if (faces->size() > 0){ + while(faces->size() > 0) { + info->patch_cnt++; + size_t new_patch = info->patch_cnt; + std::queue<size_t> face_queue; + face_queue.push((*faces->begin())); + faces->erase(face_queue.front()); + size_t start_face_num = face_queue.front(); + info->patch_to_plane[new_patch] = info->face_to_plane[face_queue.front()]; + while (!face_queue.empty()) { + size_t face_num = face_queue.front(); + face_queue.pop(); + (*patches)[new_patch].insert(face_num); + info->face_to_patch[face_num] = new_patch; + std::set<size_t> connected_faces; + std::set<size_t>::iterator cf_it; + get_connected_faces(info->bot, face_num, &(info->edge_to_face), &connected_faces); + for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { + if(faces->find((*cf_it)) != faces->end()) { + if(ON_DotProduct( *(*info).face_normals.At((int)(start_face_num)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { + face_queue.push((*cf_it)); + faces->erase((*cf_it)); +} + } + } + } + } + } +} + +void split_overlapping_patch(size_t face1, size_t face2, size_t orig_patch, std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info) { + std::set<size_t> *faces = &((*patches)[orig_patch]); + std::queue<size_t> face_queue_1; + std::queue<size_t> face_queue_2; + face_queue_1.push(*faces->find(face1)); + faces->erase(face_queue_1.front()); + info->patch_cnt++; + size_t new_patch_1 = info->patch_cnt; + size_t start_face_num_1 = face_queue_1.front(); + info->patch_to_plane[new_patch_1] = info->face_to_plane[face_queue_1.front()]; + face_queue_2.push(*faces->find(face2)); + faces->erase(face_queue_2.front()); + info->patch_cnt++; + size_t new_patch_2 = info->patch_cnt; + size_t start_face_num_2 = face_queue_2.front(); + info->patch_to_plane[new_patch_2] = info->face_to_plane[face_queue_2.front()]; + while (!face_queue_1.empty() || !face_queue_2.empty()) { + if (!face_queue_1.empty()) { + size_t face_num_1 = face_queue_1.front(); + face_queue_1.pop(); + (*patches)[new_patch_1].insert(face_num_1); + info->face_to_patch[face_num_1] = new_patch_1; + std::set<size_t> connected_faces; + std::set<size_t>::iterator cf_it; + get_connected_faces(info->bot, face_num_1, &(info->edge_to_face), &connected_faces); + for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { + if(faces->find((*cf_it)) != faces->end() && (*patches)[new_patch_2].find(*cf_it) == (*patches)[new_patch_2].end()) { + if(ON_DotProduct( *(*info).face_normals.At((int)(start_face_num_1)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { + face_queue_1.push((*cf_it)); + faces->erase((*cf_it)); + } + } + } + } + if (!face_queue_2.empty()) { + size_t face_num_2 = face_queue_2.front(); + face_queue_2.pop(); + (*patches)[new_patch_2].insert(face_num_2); + info->face_to_patch[face_num_2] = new_patch_2; + std::set<size_t> connected_faces; + std::set<size_t>::iterator cf_it; + get_connected_faces(info->bot, face_num_2, &(info->edge_to_face), &connected_faces); + for (cf_it = connected_faces.begin(); cf_it != connected_faces.end(); cf_it++) { + if(faces->find((*cf_it)) != faces->end() && (*patches)[new_patch_1].find(*cf_it) == (*patches)[new_patch_1].end()) { + if(ON_DotProduct( *(*info).face_normals.At(((int)start_face_num_2)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { + face_queue_2.push((*cf_it)); + faces->erase((*cf_it)); +} + } + } + } + } + if (faces->size() > 0) construct_patches(faces, patches, info); +} + +// Given a patch, find triangles that overlap when projected into the patch domain, remove them +// from the current patch and set them up in their own patch. Returns the number of faces moved +// from the current patch to their own patch. +// +// TODO - saw at least one case where triangle removal resulted one patch breaking into two +// topological patches. Need to handle this, otherwise Bad Things will happen when trying +// to generate BREPs. +// Also - need to check how the nurbs fitting code is calculating their initial plane, and use +// that for this test rather than the original faces - it is projection into *THAT* plane that +// must be clean, and a projection clean in the "standard" direction may not be clean there. +size_t overlapping_edge_triangles(std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info) +{ + size_t total_overlapping = 0; + std::map< size_t, std::set<size_t> >::iterator p_it; + for (p_it = patches->begin(); p_it != patches->end(); p_it++) { + if ((*p_it).second.size() > 0) { + ON_Plane plane; + fit_plane((*p_it).first, &((*p_it).second), info, &plane); + ON_Xform xf; + xf.PlanarProjection(plane); + size_t overlap_cnt = 1; + size_t patch_overlapping = 0; + while (overlap_cnt != 0) { + std::set<size_t> edge_triangles; + EdgeList edges; + find_edge_segments(&((*p_it).second), &edges, info); + EdgeList::iterator e_it; + std::set<size_t>::iterator sizet_it; + // 1. build triangle set of edge triangles in patch. + for (e_it = edges.begin(); e_it != edges.end(); e_it++) { + std::set<size_t> faces_from_edge = info->edge_to_face[(*e_it)]; + for (sizet_it = faces_from_edge.begin(); sizet_it != faces_from_edge.end() ; sizet_it++) { + if (info->face_to_patch[(*sizet_it)] == (*p_it).first) { + edge_triangles.insert((*sizet_it)); + } + } + } + // 2. Find an overlapping triangle, remove it to its own patch, fix the edges, continue + overlap_cnt = 0; + for (sizet_it = edge_triangles.begin(); sizet_it != edge_triangles.end() ; sizet_it++) { + point_t v0, v1, v2; + ON_3dPoint onpt_v0(&info->bot->vertices[info->bot->faces[(*sizet_it)*3+0]*3]); + ON_3dPoint onpt_v1(&info->bot->vertices[info->bot->faces[(*sizet_it)*3+1]*3]); + ON_3dPoint onpt_v2(&info->bot->vertices[info->bot->faces[(*sizet_it)*3+2]*3]); + onpt_v0.Transform(xf); + onpt_v1.Transform(xf); + onpt_v2.Transform(xf); + VSET(v0, onpt_v0.x, onpt_v0.y, onpt_v0.z); + VSET(v1, onpt_v1.x, onpt_v1.y, onpt_v1.z); + VSET(v2, onpt_v2.x, onpt_v2.y, onpt_v2.z); + edge_triangles.erase(*sizet_it); + std::set<size_t>::iterator ef_it2 = edge_triangles.begin(); + for (ef_it2 = edge_triangles.begin(); ef_it2!=edge_triangles.end(); ef_it2++) { + if ((*sizet_it) != (*ef_it2)) { + point_t u0, u1, u2; + ON_3dPoint onpt_u0(&info->bot->vertices[info->bot->faces[(*ef_it2)*3+0]*3]); + ON_3dPoint onpt_u1(&info->bot->vertices[info->bot->faces[(*ef_it2)*3+1]*3]); + ON_3dPoint onpt_u2(&info->bot->vertices[info->bot->faces[(*ef_it2)*3+2]*3]); + onpt_u0.Transform(xf); + onpt_u1.Transform(xf); + onpt_u2.Transform(xf); + VSET(u0, onpt_u0.x, onpt_u0.y, onpt_u0.z); + VSET(u1, onpt_u1.x, onpt_u1.y, onpt_u1.z); + VSET(u2, onpt_u2.x, onpt_u2.y, onpt_u2.z); + int overlap = bn_coplanar_tri_tri_isect(v0, v1, v2, u0, u1, u2, 1); + if (overlap) { + std::cout << "Patch " << (*p_it).first << " overlap: (" << *sizet_it << "," << *ef_it2 << ")\n"; + split_overlapping_patch(*sizet_it, *ef_it2, (*p_it).first, patches, info); +#if 0 + info->patch_cnt++; + size_t new_patch = info->patch_cnt; + (*patches)[new_patch].insert(*sizet_it); + (*patches)[(*p_it).first].erase(*sizet_it); + info->patch_to_plane[new_patch] = info->face_to_plane[*sizet_it]; + info->face_to_patch[*sizet_it] = new_patch; + find_edge_segments(&((*p_it).second), &edges, info); +#endif + overlap_cnt++; + patch_overlapping++; + total_overlapping++; + } + } + if (overlap_cnt > 0) break; + } + if (overlap_cnt > 0) break; + } + } +// verify_patch_integrity((*p_it).first, &((*p_it).second), patches, info); + } + } + return total_overlapping; +} + +void bot_partition(struct Manifold_Info *info) +{ + std::map< size_t, std::set<size_t> > face_groups; + std::map< size_t, std::set<size_t> > patches; + // Calculate face normals dot product with bounding rpp planes + for (size_t i=0; i < info->bot->num_faces; ++i) { + size_t pt_A, pt_B, pt_C; + size_t result_max; + double vdot = 0.0; + double result = 0.0; + vect_t a, b, norm_dir; + // Add vert -> edge and edge -> face mappings to global map. + pt_A = info->bot->faces[i*3+0]*3; + pt_B = info->bot->faces[i*3+1]*3; + pt_C = info->bot->faces[i*3+2]*3; + info->edge_to_face[mk_edge(pt_A, pt_B)].insert(i); + info->edge_to_face[mk_edge(pt_B, pt_C)].insert(i); + info->edge_to_face[mk_edge(pt_C, pt_A)].insert(i); + // Categorize face + VSUB2(a, &info->bot->vertices[info->bot->faces[i*3+1]*3], &info->bot->vertices[info->bot->faces[i*3]*3]); + VSUB2(b, &info->bot->vertices[info->bot->faces[i*3+2]*3], &info->bot->vertices[info->bot->faces[i*3]*3]); + VCROSS(norm_dir, a, b); + VUNITIZE(norm_dir); + info->face_normals.Append(ON_3dVector(norm_dir[0], norm_dir[1], norm_dir[2])); + (*info).face_normals.At((int)i)->Unitize(); + for (size_t j=0; j < (size_t)(*info).vectors.Count(); j++) { + vdot = ON_DotProduct(*(*info).vectors.At((int)j), *(*info).face_normals.At((int)i)); + info->norm_results[std::make_pair(i, j)] = vdot; + if (vdot > result) { + result_max = j; + result = vdot; + } + } + face_groups[result_max].insert(i); + info->face_to_plane[i]=result_max; + } + // Sort the groups by their face count - we want to start with the group containing + // either the least or the most faces - try most. + std::map< size_t, std::set<size_t> >::iterator fg_it; + std::vector<size_t> ordered_vects((*info).vectors.Count()); + std::set<int> face_group_set; + for (int i = 0; i < (*info).vectors.Count(); i++) { + face_group_set.insert(i); + } + size_t array_pos = 0; + while (!face_group_set.empty()) { + size_t curr_max = 0; + size_t curr_vect = 0; + for (fg_it = face_groups.begin(); fg_it != face_groups.end(); fg_it++) { + if ((*fg_it).second.size() > curr_max) { + if (face_group_set.find((*fg_it).first) != face_group_set.end()) { + curr_max = (*fg_it).second.size(); + curr_vect = (*fg_it).first; + } + } + } + ordered_vects.at(array_pos) = curr_vect; + face_group_set.erase(curr_vect); + array_pos++; + } + + // All faces must belong to some patch - continue until all faces are processed + for (int i = 0; i < 6; i++) { + fg_it = face_groups.find(ordered_vects.at(i)); + std::set<size_t> *faces = &((*fg_it).second); + while (!faces->empty()) { + info->patch_cnt++; + // Find largest remaining face in group + double face_size_criteria = 0.0; + size_t smallest_face = 0; + for (std::set<size_t>::iterator fgl_it = faces->begin(); fgl_it != faces->end(); fgl_it++) { + double fa = face_area(info->bot, *fgl_it); + if (fa > face_size_criteria) { + smallest_face = (*fgl_it); + face_size_criteria = fa; + } + } + std::queue<size_t> face_queue; + FaceList::iterator f_it; + face_queue.push(smallest_face); + face_groups[info->face_to_plane[face_queue.front()]].erase(face_queue.front()); + size_t current_plane = info->face_to_plane[face_queue.front()]; + //size_t start_face_num = face_queue.front(); + while (!face_queue.empty()) { + size_t face_num = face_queue.front(); + face_queue.pop(); + patches[info->patch_cnt].insert(face_num); + info->patch_to_plane[info->patch_cnt] = current_plane; + info->face_to_patch[face_num] = info->patch_cnt; + + std::set<size_t> connected_faces; + std::set<size_t>::iterator cf_it; + get_connected_faces(info->bot, face_num, &(info->edge_to_face), &connected_faces); + for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { + double curr_face_area = face_area(info->bot, (*cf_it)); + if (curr_face_area < (face_size_criteria*10) && curr_face_area > (face_size_criteria*0.1)) { + if (face_groups[info->face_to_plane[(*cf_it)]].find((*cf_it)) != face_groups[info->face_to_plane[(*cf_it)]].end()) { + if (info->face_to_plane[(*cf_it)] == current_plane) { + // if(ON_DotProduct( *(*info).face_normals.At((start_face_num)),*(*info).face_normals.At((*cf_it)) ) > 0.5) { + // Large patches pose a problem for feature preservation - make an attempt to ensure "large" + // patches are flat. + if (patches[info->patch_cnt].size() > info->patch_size_threshold) { + vect_t origin; + size_t ok = 1; + VMOVE(origin, &info->bot->vertices[info->bot->faces[(face_num)*3]*3]); + ON_Plane plane(ON_3dPoint(origin[0], origin[1], origin[2]), *(*info).face_normals.At((int)(face_num))); + for (int pt = 0; pt < 3; pt++) { + point_t cpt; + VMOVE(cpt, &info->bot->vertices[info->bot->faces[((*cf_it))*3+pt]*3]); + double dist_to_plane = plane.DistanceTo(ON_3dPoint(cpt[0], cpt[1], cpt[2])); + //std::cout << "Distance[" << face_num << "," << (*cf_it) << "](" << pt << "): " << dist_to_plane << "\n"; + if (dist_to_plane > 0) { + double dist = DIST_PT_PT(origin, cpt); + double angle = atan(dist_to_plane/dist); + if (angle > info->neighbor_angle_threshold) ok = 0; + } + } + if (ok) { + face_queue.push((*cf_it)); + face_groups[info->face_to_plane[(*cf_it)]].erase((*cf_it)); + } + } else { + face_queue.push((*cf_it)); + face_groups[info->face_to_plane[(*cf_it)]].erase((*cf_it)); + } + // } + } + } + } + } + } + } + } + + // Find "interior" patches and see if they can be merged with the parent patch + + + // "Shave" sharp triangles off of the edges by shifting them from one patch to + // another - doesn't avoid all sharp corners, but does produce some cleanup. + + std::map< size_t, std::set<size_t> >::iterator p_it; + size_t shaved_cnt = 1; + size_t edge_smoothing_count = 0; + while (shaved_cnt != 0 && edge_smoothing_count <= 20) { + shaved_cnt = 0; + edge_smoothing_count++; + for (p_it = patches.begin(); p_it != patches.end(); p_it++) { + shaved_cnt += shift_edge_triangles(&patches, (*p_it).first, info); + } + std::cout << "Triangle shifts in smoothing pass " << edge_smoothing_count << ": " << shaved_cnt << "\n"; + } + + // Identify triangles that overlap in the patches associated high-level planar projection, and + // assign them to their own patches - they pose a problem for surface fitting if left in the + // original overlapping patches. + size_t overlapping_face_cnt = 0; + overlapping_face_cnt = overlapping_edge_triangles(&patches, info); + std::cout << "Found " << overlapping_face_cnt << " overlapping faces in projection\n"; + + // now, populate &(info->patches) with the non-empty patches and fix *_to_patch (maybe make that + // part of sync_structure_maps. + std::ofstream patch_map; + patch_map.open("patch_map.txt"); + for (p_it = patches.begin(); p_it != patches.end(); p_it++) { + if (patches[(*p_it).first].size() > 0) { + patch_map << (*p_it).first << " -> " << info->patches.size() << "\n"; + info->patches[info->patches.size()].insert(patches[(*p_it).first].begin(), patches[(*p_it).first].end()); + } + } + patch_map.close(); + + std::cout << "Patch count: " << info->patches.size() << "\n"; + plot_faces(&(info->patches), info, "patches.pl"); + plot_patch_borders(&(info->patches), info, "patch_borders.pl"); + + // Now that the mesh is fully partitioned, build the maps needed for curve discovery + sync_structure_maps(info); +} + +/********************************************************************************** + * + * Code for moving from patches with edge segments to a structured topology + * of curve segments and loops. + * + **********************************************************************************/ +void find_edges(struct Manifold_Info *info) +{ + std::map< size_t, size_t> vert_to_m_V; // Keep mapping between vertex index being used in Brep and BoT index + std::map< size_t, std::set<size_t> >::iterator p_it; + std::map< size_t, EdgeList > all_patch_edges; + for (p_it = info->patches.begin(); p_it != info->patches.end(); p_it++) { + if (!info->patches[(*p_it).first].empty()) { + find_edge_segments(&((*p_it).second), &(all_patch_edges[(*p_it).first]), info); + } + } + FILE* pcurveplot = fopen("polycurves.pl", "w"); + FILE *nurbs_curves = fopen("nurbs_curves.pl", "w"); + FILE *curves_plot = fopen("curves.pl", "w"); + for (p_it = info->patches.begin(); p_it != info->patches.end(); p_it++) { + if (!info->patches[(*p_it).first].empty()) { + EdgeList *patch_edges = &(all_patch_edges[(*p_it).first]); + while (!patch_edges->empty()) { + // We know the current patch - find out what the other one is for + // this edge. + const Edge *first_edge = &(*(patch_edges->begin())); + std::set<size_t> edge_patches = (*(info->edge_to_patch.find(*first_edge))).second; + edge_patches.erase((*p_it).first); + size_t other_patch_id = *(edge_patches.begin()); + // Now we know our patches - we need to start with the first line + // segment, and build up a set of edges until one of the halting + // criteria is met. + std::set<Edge> polycurve_edges; + std::set<Edge>::iterator pc_it; + std::queue<Edge> edge_queue; + edge_queue.push(*(patch_edges->begin())); + all_patch_edges[(*p_it).first].erase(edge_queue.front()); + all_patch_edges[other_patch_id].erase(edge_queue.front()); + while (!edge_queue.empty()) { + // Add the first edge in the queue + Edge curr_edge = edge_queue.front(); + edge_queue.pop(); + polycurve_edges.insert(curr_edge); + //std::cout << "Current edge: (" << curr_edge.first << "," << curr_edge.second << ")\n"; + + // Using the current edge, identify candidate edges and evaluate them. + std::set<Edge> eset; + std::set<Edge>::iterator e_it; + // If a vertex is used by three patches, it is a stopping point for curve + // buildup. Otherwise, consider its edges. + if (info->vert_to_patch[curr_edge.first].size() <= 2) { + eset.insert(info->vert_to_edge[curr_edge.first].begin(), info->vert_to_edge[curr_edge.first].end()); + } + if (info->vert_to_patch[curr_edge.second].size() <= 2) { + eset.insert(info->vert_to_edge[curr_edge.second].begin(), info->vert_to_edge[curr_edge.second].end()); + } + // We don't need to re-consider any edge we've already considered. + for (e_it = eset.begin(); e_it != eset.end(); e_it++) { + if (polycurve_edges.find((*e_it)) != polycurve_edges.end()) { + eset.erase((*e_it)); + } + } + // For the new candidate edges, pull their patches and see if + // they match the current patches. If they do, and the edge has not + // already been removed from one of the patches, this edge is part of + // the current polycurve. + for (e_it = eset.begin(); e_it != eset.end(); e_it++) { + std::set<size_t> *ep = &(info->edge_to_patch[(*e_it)]); + if (ep->find(other_patch_id) != ep->end() && ep->find((*p_it).first) != ep->end() && polycurve_edges.find(*e_it) == polycurve_edges.end()) { + edge_queue.push(*e_it); + all_patch_edges[(*p_it).first].erase(*e_it); + all_patch_edges[other_patch_id].erase(*e_it); + } + } + } + // populate polycurve + std::map<size_t, std::set<size_t> > vert_to_verts; + std::map<size_t, std::set<size_t> >::iterator vv_it; + for (pc_it = polycurve_edges.begin(); pc_it != polycurve_edges.end(); pc_it++) { + vert_to_verts[(*pc_it).first].insert((*pc_it).second); + vert_to_verts[(*pc_it).second].insert((*pc_it).first); + } + // Find start and end points, if any + std::pair<size_t, size_t> start_end; + start_end.first = INT_MAX; + start_end.second = INT_MAX; + for (vv_it = vert_to_verts.begin(); vv_it != vert_to_verts.end(); vv_it++) { + if ((*vv_it).second.size() == 1) { + if (start_end.first == INT_MAX) { + start_end.first = (*vv_it).first; + } else { + if (start_end.second == INT_MAX) { + start_end.second = (*vv_it).first; + } + } + } + } + // Get curve ID number + size_t curve_id = info->polycurves.size(); + + // If we have a loop, need different halting conditions for + // curve assembly. + size_t threshold = 0; + if (start_end.first == INT_MAX && start_end.second == INT_MAX) { + threshold = 1; + start_end.first = *(*vert_to_verts.begin()).second.begin(); + start_end.second = *(*vert_to_verts.begin()).second.begin(); + } + + // Using the starting point, build a vector with the points + // in curve order. + size_t next_pt = start_end.first; + size_t start_end_cnt = 0; + while (start_end_cnt <= threshold) { + if (next_pt == start_end.second) start_end_cnt++; + size_t old_pt = next_pt; + info->polycurves[curve_id].push_back(old_pt); + next_pt = *(vert_to_verts[old_pt].begin()); + vert_to_verts[next_pt].erase(old_pt); + } + + // Make m_V vertices out of start and end, m_C3 curve of fit, and BrepEdge using + // start/end pts and curve. When new edge is added, brep->m_E.Count() is the index + // of the new edge. - get it with ON_BrepEdge* edge = brep.Edge(ei); verts are m_vi[0] or m_vi[1], + // or (possibly) edge.Vertex(0) + int vs_id, ve_id; + if (vert_to_m_V.find(start_end.first) == vert_to_m_V.end()) { + ON_BrepVertex& newV = info->brep->NewVertex(ON_3dPoint(&info->bot->vertices[start_end.first]), 0.0001); + vs_id = newV.m_vertex_index; + vert_to_m_V[start_end.first] = vs_id; + } else { + vs_id = vert_to_m_V[start_end.first]; + } + if (vert_to_m_V.find(start_end.second) == vert_to_m_V.end()) { + ON_BrepVertex& newV = info->brep->NewVertex(ON_3dPoint(&info->bot->vertices[start_end.second]), 0.0001); + ve_id = newV.m_vertex_index; + vert_to_m_V[start_end.second] = ve_id; + } else { + ve_id = vert_to_m_V[start_end.second]; + } + ON_3dPointArray curve_pnts; + std::vector<size_t>::iterator v_it; + // TODO - for curves from patches that had to have triangles removed, need to add + // additional points - a loose fit runs the risk of overlapping NURBS curves in + // projections. May even need a different fit for those situations - worst case, + // use linear edges instead of smooth approximations for all curves that initially failed the + // overlapping triangles test. + for (v_it = info->polycurves[curve_id].begin(); v_it != info->polycurves[curve_id].end(); v_it++) { + ON_3dPoint pt_3d(&info->bot->vertices[(*v_it)]); + curve_pnts.Append(pt_3d); + } + ON_NurbsCurve *curve_nurb; + int c3i; + if (curve_pnts.Count() == 2) { + c3i = info->brep->AddEdgeCurve(new ON_LineCurve(*(curve_pnts.First()), *(curve_pnts.Last()))); + } else { + curve_nurb = interpolateLocalCubicCurve(curve_pnts); + c3i = info->brep->AddEdgeCurve(curve_nurb); + } + ON_BrepVertex& StartV = info->brep->m_V[vs_id]; + StartV.m_tolerance = 1e-3; + ON_BrepVertex& EndV= info->brep->m_V[ve_id]; + EndV.m_tolerance = 1e-3; + ON_BrepEdge& edge = info->brep->NewEdge(StartV, EndV, c3i, NULL ,0); + edge.m_tolerance = 1e-3; + + // Let the patches know they have a curve associated with them. + info->patch_edges[(*p_it).first].insert(edge.m_edge_index); + info->patch_edges[other_patch_id].insert(edge.m_edge_index); + + // Plot curve + int r = int(256*drand48() + 1.0); + int g = int(256*drand48() + 1.0); + int b = int(256*drand48() + 1.0); + plot_curve(info->bot, &(info->polycurves[curve_id]), r, g, b, pcurveplot); + plot_curve(info->bot, &(info->polycurves[curve_id]), r, g, b, curves_plot); + + pl_color(nurbs_curves, r, g, b); + double pt1[3], pt2[3]; + int plotres = 50; + const ON_Curve* edge_curve = edge.EdgeCurveOf(); + ON_Interval dom = edge_curve->Domain(); + for (int i = 1; i <= 50; i++) { + ON_3dPoint p = edge_curve->PointAt(dom.ParameterAt((double)(i - 1) + / (double)plotres)); + VMOVE(pt1, p); + p = edge_curve->PointAt(dom.ParameterAt((double) i / (double)plotres)); + VMOVE(pt2, p); + pdv_3move(nurbs_curves, pt1); + pdv_3cont(nurbs_curves, pt2); + pdv_3move(curves_plot, pt1); + pdv_3cont(curves_plot, pt2); + } + + } + } + } + fclose(curves_plot); + fclose(nurbs_curves); + fclose(pcurveplot); +} + + +void find_outer_loop(std::map<size_t, std::vector<size_t> > *loops, size_t *outer_loop, std::set<size_t> *inner_loops, struct Manifold_Info *info) +{ + // If we have more than one loop, we need to identify the outer loop. OpenNURBS handles outer + // and inner loops separately, so we need to know which loop is our outer surface boundary. + if ((*loops).size() == 1) { + *outer_loop = 0; + } else { + std::map<size_t, std::vector<size_t> >::iterator l_it; + fastf_t diag_max = 0.0; + for(l_it = loops->begin(); l_it != loops->end(); l_it++) { + double boxmin[3] = {0.0, 0.0, 0.0}; + double boxmax[3] = {0.0, 0.0, 0.0}; + std::vector<size_t>::iterator v_it; + for(v_it = (*l_it).second.begin(); v_it != (*l_it).second.end(); v_it++) { + ON_BrepEdge& edge = info->brep->m_E[(int)(*v_it)]; + const ON_Curve* edge_curve = edge.EdgeCurveOf(); + edge_curve->GetBBox((double *)&boxmin, (double *)&boxmax, 1); + } + ON_3dPoint pmin(boxmin[0], boxmin[1], boxmin[2]); + ON_3dPoint pmax(boxmax[0], boxmax[1], boxmax[2]); + if (pmin.DistanceTo(pmax) > diag_max) { + *outer_loop = (*l_it).first; + diag_max = pmin.DistanceTo(pmax); + } + } + for(l_it = loops->begin(); l_it != loops->end(); l_it++) { + if((*l_it).first != *outer_loop) { + (*inner_loops).insert((*l_it).first); + } + } + } +} + +// Do pullbacks to generate trimming curves in 2D, use them to create BrepTrim and BrepLoop structures for +// outer and inner trimming loops +void build_loop(size_t patch_id, size_t loop_index, ON_BrepLoop::TYPE loop_type, std::map<size_t, std::vector<size_t> > *loops, struct Manifold_Info *info) { + + ON_BrepFace& face = info->brep->m_F[(int)patch_id]; + const ON_Surface *surface = face.SurfaceOf(); + ON_Interval xdom = surface->Domain(0); + ON_Interval ydom = surface->Domain(1); + // Start with outer loop + ON_BrepLoop& loop = info->brep->NewLoop(loop_type, face); + // build surface tree + brlcad::SurfaceTree* st = new brlcad::SurfaceTree(&face, false); + + std::vector<size_t>::iterator loop_it; + std::vector<size_t> *loop_edges = &((*loops)[loop_index]); + int vert_prev = -1; + //std::cout << "Patch " << patch_id << " loop edges: \n"; + bool trim_rev = false; + for(loop_it = loop_edges->begin(); loop_it != loop_edges->end(); loop_it++) { + size_t curr_edge = (*loop_it); + // Will we need to flip the trim? + ON_BrepEdge& edge = info->brep->m_E[(int)curr_edge]; + if(vert_prev != -1) { + if (vert_prev == edge.m_vi[0]) { + trim_rev = false; + } else { + trim_rev = true; + } + } + if(trim_rev) { + vert_prev = edge.m_vi[0]; + } else { + vert_prev = edge.m_vi[1]; + } + //std::cout << "edge verts: " << edge.m_vi[0] << "," << edge.m_vi[1] << " flip=" << trim_rev << "\n"; + + ON_2dPointArray curve_pnts_2d; + const ON_Curve* edge_curve = edge.EdgeCurveOf(); + ON_Interval dom = edge_curve->Domain(); + + ON_3dPoint pt_3d = edge_curve->PointAt(dom.ParameterAt(0)); + ON_2dPoint pt_2d; + ON_2dPoint loop_anchor; + ON_2dPoint pt_2d_prev; + int prev_trim_rev = 0; + int istart = 1; + + size_t pullback_failures; + if(loop_it == loop_edges->begin()) { + pullback_failures = 0; + prev_trim_rev = trim_rev; + int found_first_pt = 0; + while(!found_first_pt && istart < 50) { + pt_3d = edge_curve->PointAt(dom.ParameterAt((double)(istart-1)/(double)50)); + if(get_closest_point(pt_2d, &face, pt_3d, st)) { + if (xdom.Includes(pt_2d.x) && ydom.Includes(pt_2d.y)) { + curve_pnts_2d.Append(pt_2d); + loop_anchor = pt_2d; + found_first_pt = 1; + } else { + istart++; + } + } else { + std::cout << "Pullback failure on first pt (" << patch_id << "," << curr_edge << "," << (double)(istart-1)/(double)50 << "): " << pt_3d.x << " " << pt_3d.y << " " << pt_3d.z << "\n"; + pullback_failures++; + istart++; + } + } + } else { + curve_pnts_2d.Append(pt_2d_prev); + } + // XXX todo: dynamically sample the curve - must use consistent method for all sampling, else + // surface may not contain points sought by curve + if(!trim_rev) { + for (int i = istart; i < 50; i++) { + pt_3d = edge_curve->PointAt(dom.ParameterAt((double)(i)/(double)50)); + if(get_closest_point(pt_2d, &face, pt_3d, st) && pt_2d != pt_2d_prev) { + if (xdom.Includes(pt_2d.x) && ydom.Includes(pt_2d.y)) { + curve_pnts_2d.Append(pt_2d); + pt_2d_prev = pt_2d; + } + } else { + std::cout << "Pullback failure (" << patch_id << "," << curr_edge << "," << (double)(i)/(double)50 << "): " << pt_3d.x << " " << pt_3d.y << " " << pt_3d.z << "\n"; + pullback_failures++; + } + } + } else { + for (int i = 50; i > istart; i--) { + pt_3d = edge_curve->PointAt(dom.ParameterAt((double)(i)/(double)50)); + if(get_closest_point(pt_2d, &face, pt_3d, st) && pt_2d != pt_2d_prev) { + if (xdom.Includes(pt_2d.x) && ydom.Includes(pt_2d.y)) { + curve_pnts_2d.Append(pt_2d); + pt_2d_prev = pt_2d; + } + } else { + std::cout << "Pullback failure (" << patch_id << "," << curr_edge << "," << (double)(i)/(double)50 << "): " << pt_3d.x << " " << pt_3d.y << " " << pt_3d.z << "\n"; + pullback_failures++; + } + } + } + // For final curve, doesn't matter what last pullback is - we MUST force the loop to close. + if(loop_it+1 == loop_edges->end()) { + curve_pnts_2d.Append(loop_anchor); + } + //if(trim_rev) {curve_pnts_2d.Reverse();} + ON_Curve *trim_curve = interpolateCurve(curve_pnts_2d); + int c2i = info->brep->AddTrimCurve(trim_curve); + ON_BrepTrim& trim = info->brep->NewTrim(edge, trim_rev, loop, c2i); + trim.m_type = ON_BrepTrim::mated; + trim.m_tolerance[0] = 1e-3; + trim.m_tolerance[1] = 1e-3; + } + if (info->brep->LoopDirection(loop) != 1 && loop_type == ON_BrepLoop::outer) { + info->brep->FlipLoop(loop); + } + if (info->brep->LoopDirection(loop) != -1 && loop_type == ON_BrepLoop::inner) { + info->brep->FlipLoop(loop); + } + delete st; +} + +void find_loops(struct Manifold_Info *info) +{ + std::map< size_t, std::set<size_t> >::iterator p_it; + for (p_it = info->patch_edges.begin(); p_it != info->patch_edges.end(); p_it++) { + std::map<size_t, std::vector<size_t> > loops; + std::map<size_t, std::set<size_t> > vert_to_edges; + struct bu_vls name; + bu_vls_init(&name); + bu_vls_printf(&name, "loops_patch_%d.pl", (int)(*p_it).first); + FILE* ploopplot = fopen(bu_vls_addr(&name), "w"); + std::set<size_t> curr_edges = (*p_it).second; + for (std::set<size_t>::iterator edge_it = curr_edges.begin(); edge_it != curr_edges.end(); edge_it++) { + ON_BrepEdge& edge = info->brep->m_E[(int)(*edge_it)]; + if (edge.m_vi[0] == edge.m_vi[1]) { + size_t curr_loop = loops.size(); + loops[curr_loop].push_back((*edge_it)); + plot_loop(&loops[curr_loop], info, ploopplot); + curr_edges.erase(*edge_it); + } else { + vert_to_edges[edge.m_vi[0]].insert(*edge_it); + vert_to_edges[edge.m_vi[1]].insert(*edge_it); + } + } + + while (curr_edges.size() > 0) { + size_t curr_loop = loops.size(); + std::queue<size_t> edge_queue; + edge_queue.push(*(curr_edges.begin())); + curr_edges.erase(edge_queue.front()); + int vert_to_match = info->brep->m_E[(int)edge_queue.front()].m_vi[0]; + while (!edge_queue.empty()) { + size_t curr_edge = edge_queue.front(); + edge_queue.pop(); + loops[curr_loop].push_back(curr_edge); + ON_BrepEdge& edge = info->brep->m_E[(int)curr_edge]; + if(vert_to_match == edge.m_vi[0]) { + vert_to_match = edge.m_vi[1]; + } else { + vert_to_match = edge.m_vi[0]; + } + // use vert_to_edges to assemble other curves + std::set<size_t> candidate_edges; + candidate_edges.insert(vert_to_edges[vert_to_match].begin(), vert_to_edges[vert_to_match].end()); + candidate_edges.erase(curr_edge); + for (std::set<size_t>::iterator c_it = candidate_edges.begin(); c_it != candidate_edges.end(); c_it++) { + if (curr_edges.find(*c_it) != curr_edges.end()) { + edge_queue.push(*c_it); + curr_edges.erase(*c_it); + } + } + } +#ifdef BOT_TO_NURBS_DEBUG + std::cout << "Patch " << (*p_it).first << " loop " << curr_loop << ": "; + for (size_t i = 0; i < loops[curr_loop].size(); i++) { + std::cout << loops[curr_loop][i] << ","; + } + std::cout << "\n"; +#endif + plot_loop(&loops[curr_loop], info, ploopplot); + } + fclose(ploopplot); + // Now that we have loops, determine which is the outer loop + size_t outer_loop; + std::set<size_t> inner_loops; + find_outer_loop(&loops, &outer_loop, &inner_loops, info); + if(loops.size() > 1) { + std::cout << "Patch " << (*p_it).first << " outer loop: " << outer_loop << "\n"; + } + + build_loop((*p_it).first, outer_loop, ON_BrepLoop::outer, &loops, info); + // If there are any inner loops, build them too + for (std::set<size_t>::iterator il_it = inner_loops.begin(); il_it != inner_loops.end(); il_it++) { + build_loop((*p_it).first, (*il_it), ON_BrepLoop::inner, &loops, info); + } + } +} + +/********************************************************************************** + * + * Code for fitted 3D NURBS surfaces to patches. + * + **********************************************************************************/ + +void PatchToVector3d(struct rt_bot_internal *bot, size_t curr_patch, struct Manifold_Info *info, on_fit::vector_vec3d &data) +{ + std::set<size_t> *faces = &(info->patches[curr_patch]); + std::set<size_t>::iterator f_it; + std::set<size_t> verts; + unsigned int i = 0; + ON_3dPointArray pnts; + for (i = 0; i < bot->num_vertices; i++) { + //printf("v(%d): %f %f %f\n", i, V3ARGS(&bot->vertices[3*i])); + } + for (f_it = faces->begin(); f_it != faces->end(); f_it++) { + verts.insert(bot->faces[(*f_it)*3+0]); + verts.insert(bot->faces[(*f_it)*3+1]); + verts.insert(bot->faces[(*f_it)*3+2]); + } + for (f_it = verts.begin(); f_it != verts.end(); f_it++) { + //printf("vert %d\n", (int)(*f_it)); + //printf("vert(%d): %f %f %f\n", (int)(*f_it), V3ARGS(&bot->vertices[(*f_it)*3])); + data.push_back(ON_3dVector(V3ARGS(&bot->vertices[(*f_it)*3]))); + pnts.Append(ON_3dPoint(V3ARGS(&bot->vertices[(*f_it)*3]))); + } + + // Points on the edges of surfaces make problems for our current 2D uv pullback routine. + // Try to force the surface edges away from the actual patch boundaries by adding "extension" + // points to the fit. + ON_BoundingBox bbox; + pnts.GetTightBoundingBox(bbox); + fastf_t diagonal = bbox.Diagonal().Length(); + ON_Plane best_fit_plane; + fit_plane(curr_patch, faces, info, &best_fit_plane); +/* + fastf_t greatest_distance_to_plane = 0.0; + for (int j = 0; j < pnts.Count(); ++j) { + fastf_t dist = best_fit_plane.DistanceTo(pnts[j]); + if (dist > greatest_distance_to_plane) greatest_distance_to_plane = dist; + } + ON_3dVector move = best_fit_plane.Normal(); + double vdot = ON_DotProduct(move, *info->face_normals.At((int)*(info->patches[curr_patch].begin()))); + if (vdot > 0.05) move.Reverse(); + ON_3dPoint newcenter = best_fit_plane.Origin() + move * greatest_distance_to_plane; + best_fit_plane.SetOrigin(newcenter); +*/ + struct bu_vls filename; + bu_vls_init(&filename); + bu_vls_sprintf(&filename, "extensions_%d.pl", curr_patch); + FILE* edge_plot = fopen(bu_vls_addr(&filename), "w"); + EdgeList patch_edges_extend; + EdgeList::iterator e_it; + point_t pt1, pt2; + VSET(pt1, best_fit_plane.Origin().x, best_fit_plane.Origin().y, best_fit_plane.Origin().z) + ON_Circle bounding_circle(best_fit_plane, diagonal); + for (int t = 0; t < 10; t++) { + data.push_back(ON_3dVector(bounding_circle.PointAt(t*36))); + VSET(pt2, bounding_circle.PointAt(t*36).x, bounding_circle.PointAt(t*36).y, bounding_circle.PointAt(t*36).z); + + pdv_3move(edge_plot, pt1); + pdv_3cont(edge_plot, pt2); + } + fclose(edge_plot); + + // Edges are important for patch merging - tighten them by adding more edge + // points than just the vertex points. Use points from the 3D NURBS edge curves + // instead of the bot edges to ensure the surface includes the volume needed + // for curve pullback. + std::set<size_t> *patch_edges = &(info->patch_edges[curr_patch]); + std::set<size_t>::iterator pe_it; + for (pe_it = patch_edges->begin(); pe_it != patch_edges->end(); pe_it++) { + ON_BrepEdge& edge = info->brep->m_E[(int)(*pe_it)]; + const ON_Curve* edge_curve = edge.EdgeCurveOf(); + ON_Interval dom = edge_curve->Domain(); + // XXX todo: dynamically sample the curve + ON_3dPoint pt_3d = edge_curve->PointAt(dom.ParameterAt(0)); + data.push_back(ON_3dVector(pt_3d)); + for (int ipts = 1; ipts < 50; ipts++) { + pt_3d = edge_curve->PointAt(dom.ParameterAt((double)(ipts)/(double)50)); + data.push_back(ON_3dVector(pt_3d)); + } + pt_3d = edge_curve->PointAt(dom.ParameterAt(1.0)); + data.push_back(ON_3dVector(pt_3d)); + } +} + + + // Actually fit the NURBS surfaces and build faces +void find_surfaces(struct Manifold_Info *info) { + std::map< size_t, std::set<size_t> >::iterator p_it; + for (p_it = info->patches.begin(); p_it != info->patches.end(); p_it++) { + std::cout << "Found patch " << (*p_it).first << " with " << (*p_it).second.size() << " faces\n"; + unsigned order(3); + on_fit::NurbsDataSurface data; + PatchToVector3d(info->bot, (*p_it).first, info, data.interior); + ON_NurbsSurface nurbs = on_fit::FittingSurface::initNurbsPCABoundingBox(order, &data); + on_fit::FittingSurface fit(&data, nurbs); + on_fit::FittingSurface::Parameter params; + params.interior_smoothness = 0.15; + params.interior_weight = 1.0; + params.boundary_smoothness = 0.15; + params.boundary_weight = 0.0; + // NURBS refinement + for (unsigned i = 0; i < 5; i++) { + fit.refine(0); + fit.refine(1); + } + + // fitting iterations + for (unsigned i = 0; i < 2; i++) { + fit.assemble(params); + fit.solve(); + } + + ON_BrepFace *face2 = info->brep2->NewFace(fit.m_nurbs); + info->brep2->m_S.Append(new ON_NurbsSurface(fit.m_nurbs)); + int si = info->brep->AddSurface(new ON_NurbsSurface(fit.m_nurbs)); + ON_BrepFace &face = info->brep->NewFace(si); + // Check face normal against plane + ON_Interval udom = fit.m_nurbs.Domain(0); + ON_Interval vdom = fit.m_nurbs.Domain(1); + ON_3dVector surf_norm = fit.m_nurbs.NormalAt(udom.ParameterAt(0.5), vdom.ParameterAt(0.5)); + double vdot = ON_DotProduct(surf_norm, *info->face_normals.At((int)*(info->patches[(*p_it).first].begin()))); + if (vdot < 0) { + info->brep->FlipFace(face); + info->brep2->FlipFace(*face2); + } + } +} + + +int main(int argc, char *argv[]) +{ + struct db_i *dbip; + struct directory *dp; + struct rt_db_internal intern; + struct rt_bot_internal *bot_ip = NULL; + struct rt_wdb *wdbp; + struct bu_vls name; + struct bu_vls bname; + + FaceList::iterator f_it; + + Manifold_Info info; + info.vectors.Append(ON_3dVector(-1,0,0)); + info.vectors.Append(ON_3dVector(0,-1,0)); + info.vectors.Append(ON_3dVector(0,0,-1)); + info.vectors.Append(ON_3dVector(1,0,0)); + info.vectors.Append(ON_3dVector(0,1,0)); + info.vectors.Append(ON_3dVector(0,0,1)); + // Smaller values here will do better at preserving detail but will increase patch count. + info.patch_size_threshold = 100; + // Smaller values mean more detail preservation, but result in higher patch counts. + info.neighbor_angle_threshold = 0.05; + // A "normal" value for the "parallel to projection plane" face check should be around 0.55 + info.face_plane_parallel_threshold = 0.55; + // Initialize the patch count variable + info.patch_cnt = -1; + bu_vls_init(&name); + + if (argc != 3) { + bu_exit(1, "Usage: %s file.g object", argv[0]); + } + + dbip = db_open(argv[1], "r+w"); + if (dbip == DBI_NULL) { + bu_exit(1, "ERROR: Unable to read from %s\n", argv[1]); + } + + if (db_dirbuild(dbip) < 0) + bu_exit(1, "ERROR: Unable to read from %s\n", argv[1]); + + dp = db_lookup(dbip, argv[2], LOOKUP_QUIET); + if (dp == RT_DIR_NULL) { + bu_exit(1, "ERROR: Unable to look up object %s\n", argv[2]); + } + + RT_DB_INTERNAL_INIT(&intern) + if (rt_db_get_internal(&intern, dp, dbip, NULL, &rt_uniresource) < 0) { + bu_exit(1, "ERROR: Unable to get internal representation of %s\n", argv[2]); + } + + if (intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) { + bu_exit(1, "ERROR: object %s does not appear to be of type BoT\n", argv[2]); + } else { + bot_ip = (struct rt_bot_internal *)intern.idb_ptr; + } + RT_BOT_CK_MAGIC(bot_ip); + + info.bot = bot_ip; + + // Do the initial partitioning of the mesh into patches + bu_log("Performing initial partitioning of %s\n", dp->d_namep); + bot_partition(&info); + + // Create the Brep data structure to hold curves and topology information + info.brep = ON_Brep::New(); + info.brep2 = ON_Brep::New(); + + + // Now, using the patch sets, construct brep edges + find_edges(&info); + + find_surfaces(&info); + + // Build the loops + find_loops(&info); + + // Generate BRL-CAD brep object + wdbp = wdb_dbopen(dbip, RT_WDB_TYPE_DB_DISK); + bu_vls_init(&bname); + bu_vls_sprintf(&bname, "%s_brep", argv[2]); + if (mk_brep(wdbp, bu_vls_addr(&bname), info.brep) == 0) { + bu_log("Generated brep object %s\n", bu_vls_addr(&bname)); + } + bu_vls_sprintf(&bname, "%s_brep2", argv[2]); + if (mk_brep(wdbp, bu_vls_addr(&bname), info.brep2) == 0) { + bu_log("Generated brep object %s\n", bu_vls_addr(&bname)); + } + + +//#ifdef BOT_TO_NURBS_DEBUG + for (std::map< size_t, std::set<size_t> >::iterator np_it = info.patches.begin(); np_it != info.patches.end(); np_it++) { + struct bu_vls pname; + bu_vls_init(&pname); + bu_vls_printf(&pname, "patch_%d.pl", (int)(*np_it).first); + FILE* plot_file = fopen(bu_vls_addr(&pname), "w"); + int r = int(256*drand48() + 1.0); + int g = int(256*drand48() + 1.0); + int b = int(256*drand48() + 1.0); + std::set<size_t> *nfaces = &((*np_it).second); + std::set<size_t>::iterator nf_it; + for (nf_it = nfaces->begin(); nf_it != nfaces->end(); nf_it++) { + plot_face(&bot_ip->vertices[bot_ip->faces[(*nf_it)*3+0]*3], &bot_ip->vertices[bot_ip->faces[(*nf_it)*3+1]*3], &bot_ip->vertices[bot_ip->faces[(*nf_it)*3+2]*3], r, g ,b, plot_file); + } + fclose(plot_file); + } +//#endif + +#if 0 + // SSI intersection. May need edge-based polycurves anyway to guide selection of "correct" intersection segment in the cases where + // fitted surfaces intersect multiple times - will want curves with at least the start and endpoints close to those + // of the polycurves, and the total absence of a candidate SSI curve for a given polycurve would give a local indication + // of a surface fitting problem. + FILE* curve_plot = fopen("curve_plot.pl", "w"); + pl_color(curve_plot, 255, 255, 255); + std::set<std::pair<size_t, size_t> > patch_interactions; + std::set<std::pair<size_t, size_t> >::iterator o_it; + for (p_it = info.patches.begin(); p_it != info.patches.end(); p_it++) { + EdgeList::iterator e_it; + for (e_it = info.patch_edges[(*p_it).first].begin(); e_it != info.patch_edges[(*p_it).first].end(); e_it++) { + std::set<size_t> ep = info.edge_to_patch[(*e_it)]; + ep.erase((*p_it).first); + if ((*p_it).first < (*ep.begin())) { + patch_interactions.insert(std::make_pair((*p_it).first, (*ep.begin()))); + } else { + patch_interactions.insert(std::make_pair((*ep.begin()), (*p_it).first)); + } + } + } + std::cout << "Patch interaction count: " << patch_interactions.size() << "\n"; + for (o_it = patch_interactions.begin(); o_it != patch_interactions.end(); o_it++) { + std::cout << "Intersecting " << (*o_it).first << " with " << (*o_it).second << "\n"; + ON_SimpleArray<ON_NurbsCurve*> intersect3d; + ON_SimpleArray<ON_NurbsCurve*> intersect_uv2d; + ON_SimpleArray<ON_NurbsCurve*> intersect_st2d; + brlcad::surface_surface_intersection((*(info.surface_array.At(info.patch_to_surface[(*o_it).first]))), (*(info.surface_array.At(info.patch_to_surface[(*o_it).second]))), intersect3d, intersect_uv2d, intersect_st2d); + for (int k = 0; k < intersect3d.Count(); k++) { + plot_ncurve(*(intersect3d[k]),curve_plot); + delete intersect3d[k]; + } + + } + fclose(curve_plot); +#endif + return 0; +} + +// Local Variables: +// tab-width: 8 +// mode: C++ +// c-basic-offset: 4 +// indent-tabs-mode: t +// c-file-style: "stroustrup" +// End: +// ex: shiftwidth=4 tabstop=8 Deleted: brlcad/trunk/src/librt/test_botpatches.cpp =================================================================== --- brlcad/trunk/src/librt/test_botpatches.cpp 2013-01-30 23:00:57 UTC (rev 54239) +++ brlcad/trunk/src/librt/test_botpatches.cpp 2013-01-30 23:02:46 UTC (rev 54240) @@ -1,1606 +0,0 @@ -/* TODO - Can't keep shifting the fitting plane for a triangle patch - * every time a triangle is added - too computationally expensive. - * Instead, need to make sure that the starting plane used for the - * NURBS fit is the same plane being used for the triangle overlap - * testing. Hopefully, that will preclude any "vertical or worse" - * surface fit issues while still allowing for a good surface fit, - * and avoid this business of triangles that overlap in one fit - * plane but not in another. Will probably need a change or two - * in the PCL surface fitting code.*/ - - -#include "common.h" - -#include <map> -#include <set> -#include <queue> -#include <list> -#include <vector> -#include <iostream> -#include <fstream> - -#include "vmath.h" -#include "raytrace.h" -#include "wdb.h" -#include "plot3.h" -#include "opennurbs.h" -#include "opennurbs_fit.h" -#include <Eigen/SVD> -#include "nurbs.h" - -typedef std::pair<size_t, size_t> Edge; -typedef std::map< size_t, std::set<Edge> > VertToEdge; -typedef std::map< size_t, std::set<size_t> > VertToPatch; -typedef std::map< Edge, std::set<size_t> > EdgeToPatch; -typedef std::map< Edge, std::set<size_t> > EdgeToFace; -typedef std::map< size_t, size_t > FaceToPatch; -typedef std::map< size_t, size_t > PatchToPlane; -typedef std::set<Edge> EdgeList; -typedef std::set<size_t> FaceList; - -struct Manifold_Info { - ON_Brep *brep; - ON_Brep *brep2; - struct rt_bot_internal *bot; - - std::map< size_t, std::set<size_t> > patches; - std::map< size_t, std::set<size_t> > patch_edges; - std::map< size_t, std::vector<size_t> > polycurves; - - VertToEdge vert_to_edge; - VertToPatch vert_to_patch; - EdgeToFace edge_to_face; - EdgeToPatch edge_to_patch; - FaceToPatch face_to_patch; - std::map< size_t, size_t > face_to_plane; - PatchToPlane patch_to_plane; - ON_3dVectorArray face_normals; - ON_3dVectorArray vectors; - std::map< std::pair<size_t, size_t>, fastf_t > norm_results; - size_t patch_size_threshold; - double face_plane_parallel_threshold; - double neighbor_angle_threshold; - int patch_cnt; -}; - -/********************************************************************************** - * - * Utility functions used throughout the process of fitting - * - **********************************************************************************/ - -// Make an edge using consistent vertex ordering -Edge mk_edge(size_t pt_A, size_t pt_B) -{ - if (pt_A <= pt_B) { - return std::make_pair(pt_A, pt_B); - } else { - return std::make_pair(pt_B, pt_A); - } -} - -// Calculate area of a face -double face_area(struct rt_bot_internal *bot, size_t face_num) -{ - point_t ptA, ptB, ptC; - double a, b, c, p; - double area; - VMOVE(ptA, &bot->vertices[bot->faces[face_num*3+0]*3]); - VMOVE(ptB, &bot->vertices[bot->faces[face_num*3+1]*3]); - VMOVE(ptC, &bot->vertices[bot->faces[face_num*3+2]*3]); - a = DIST_PT_PT(ptA, ptB); - b = DIST_PT_PT(ptB, ptC); - c = DIST_PT_PT(ptC, ptA); - p = (a + b + c)/2; - area = sqrt(p*(p-a)*(p-b)*(p-c)); - return area; -} - -// Given a patch consisting of a set of faces find the -// set of edges that forms the outer edge of the patch -void find_edge_segments(std::set<size_t> *faces, EdgeList *patch_edges, struct Manifold_Info *info) -{ - size_t pt_A, pt_B, pt_C; - std::set<size_t>::iterator it; - std::map<std::pair<size_t, size_t>, size_t> edge_face_cnt; - std::map<std::pair<size_t, size_t>, size_t>::iterator efc_it; - patch_edges->clear(); - for (it = faces->begin(); it != faces->end(); it++) { - pt_A = info->bot->faces[(*it)*3+0]*3; - pt_B = info->bot->faces[(*it)*3+1]*3; - pt_C = info->bot->faces[(*it)*3+2]*3; - edge_face_cnt[mk_edge(pt_A, pt_B)] += 1; - edge_face_cnt[mk_edge(pt_B, pt_C)] += 1; - edge_face_cnt[mk_edge(pt_C, pt_A)] += 1; - } - - for (efc_it = edge_face_cnt.begin(); efc_it!=edge_face_cnt.end(); efc_it++) { - if ((*efc_it).second == 1) { - info->vert_to_edge[(*efc_it).first.first].insert((*efc_it).first); - info->vert_to_edge[(*efc_it).first.second].insert((*efc_it).first); - patch_edges->insert((*efc_it).first); - } - } -} - -// Given a BoT face, return the three edges associated with that face -void get_face_edges(struct rt_bot_internal *bot, size_t face_num, std::set<Edge> *face_edges) -{ - size_t pt_A, pt_B, pt_C; - pt_A = bot->faces[face_num*3+0]*3; - pt_B = bot->faces[face_num*3+1]*3; - pt_C = bot->faces[face_num*3+2]*3; - face_edges->insert(mk_edge(pt_A, pt_B)); - face_edges->insert(mk_edge(pt_B, pt_C)); - face_edges->insert(mk_edge(pt_C, pt_A)); -} - -// Given a BoT face, return the three other faces that share an edge with that face -void get_connected_faces(struct rt_bot_internal *bot, size_t face_num, EdgeToFace *edge_to_face, std::set<size_t> *faces) -{ - std::set<Edge> face_edges; - std::set<Edge>::iterator face_edges_it; - get_face_edges(bot, face_num, &face_edges); - for (face_edges_it = face_edges.begin(); face_edges_it != face_edges.end(); face_edges_it++) { - std::set<size_t> faces_from_edge = (*edge_to_face)[(*face_edges_it)]; - std::set<size_t>::iterator ffe_it; - for (ffe_it = faces_from_edge.begin(); ffe_it != faces_from_edge.end() ; ffe_it++) { - if ((*ffe_it) != face_num) { - faces->insert((*ffe_it)); - } - } - } -} - - -// Use SVD algorithm from Soderkvist to fit a plane to vertex points -// http://www.math.ltu.se/~jove/courses/mam208/svd.pdf -void fit_plane(size_t UNUSED(patch_id), std::set<size_t> *faces, struct Manifold_Info *info, ON_Plane *plane) { - if (faces->size() > 0) { - ON_3dPoint center(0.0, 0.0, 0.0); - std::set<size_t> verts; - std::set<size_t>::iterator f_it, v_it; - for(f_it = faces->begin(); f_it != faces->end(); f_it++) { - verts.insert(info->bot->faces[(*f_it)*3+0]*3); - verts.insert(info->bot->faces[(*f_it)*3+1]*3); - verts.insert(info->bot->faces[(*f_it)*3+2]*3); - } - point_t pt; - for(v_it = verts.begin(); v_it != verts.end(); v_it++) { - VMOVE(pt, &info->bot->vertices[*v_it]); - center.x += pt[0]/verts.size(); - center.y += pt[1]/verts.size(); - center.z += pt[2]/verts.size(); - } - Eigen::MatrixXd A(3, verts.size()); - int vert_cnt = 0; - for(v_it = verts.begin(); v_it != verts.end(); v_it++) { - VMOVE(pt, &info->bot->vertices[*v_it]); - A(0,vert_cnt) = pt[0] - center.x; - A(1,vert_cnt) = pt[1] - center.y; - A(2,vert_cnt) = pt[2] - center.z; - vert_cnt++; - } - - Eigen::JacobiSVD<Eigen::MatrixXd> svd(A, Eigen::ComputeThinU); - - // 4. Normal is in column 3 of U matrix - ON_3dVector normal(svd.matrixU()(0,2), svd.matrixU()(1,2), svd.matrixU()(2,2)); - - // 5. Construct plane - ON_Plane new_plane(center, normal); - (*plane) = new_plane; -#if 0 - struct bu_vls name; - bu_vls_init(&name); - bu_vls_printf(&name, "fit_plane_%d.pl", patch_id); - FILE* plot_file = fopen(bu_vls_addr(&name), "w"); - int r = int(256*drand48() + 1.0); - int g = int(256*drand48() + 1.0); - int b = int(256*drand48() + 1.0); - point_t pc; - for(f_it = faces->begin(); f_it != faces->end(); f_it++) { - point_t p1, p2, p3; - VMOVE(p1, &info->bot->vertices[info->bot->faces[(*f_it)*3+0]*3]); - VMOVE(p2, &info->bot->vertices[info->bot->faces[(*f_it)*3+1]*3]); - VMOVE(p3, &info->bot->vertices[info->bot->faces[(*f_it)*3+2]*3]); - VSUB2(p1, p1, pc); - VSUB2(p2, p2, pc); - VSUB2(p3, p3, pc); - pdv_3move(plot_file, p1); - pdv_3cont(plot_file, p2); - pdv_3move(plot_file, p1); - pdv_3cont(plot_file, p3); - pdv_3move(plot_file, p2); - pdv_3cont(plot_file, p3); - } - pl_color(plot_file, 255, 255, 255); - point_t pn; - VSET(pc, center.x,center.y,center.z); - pdv_3move(plot_file, pc); - VSET(pn, normal.x,normal.y,normal.z); - VSCALE(pn, pn, 200); - VADD2(pn,pn,pc); - pdv_3cont(plot_file, pn); - - fclose(plot_file); -#endif - } -} - -// Check if a mesh is planar -int planar_patch_test(size_t patch_id, std::set<size_t> *faces, struct Manifold_Info *info, fastf_t tol) { - if (faces->size() == 1) return 1; - if (faces->size() > 0) { - std::set<size_t> verts; - std::set<size_t>::iterator f_it, v_it; - fastf_t max_dist = 0.0; - ON_Plane best_fit_plane; - fit_plane(patch_id, faces, info, &best_fit_plane); - for(f_it = faces->begin(); f_it != faces->end(); f_it++) { - verts.insert(info->bot->faces[(*f_it)*3+0]*3); - verts.insert(info->bot->faces[(*f_it)*3+1]*3); - verts.insert(info->bot->faces[(*f_it)*3+2]*3); - } - for(v_it = verts.begin(); v_it != verts.end(); v_it++) { - point_t pt; - VMOVE(pt, &info->bot->vertices[*v_it]); - fastf_t curr_dist = best_fit_plane.DistanceTo(ON_3dPoint(pt[0], pt[1], pt[2])); - if (curr_dist > max_dist) max_dist = curr_dist; - } - if (max_dist < tol) return 1; - return 0; - } else { - return 0; - } -} -/********************************************************************************** - * - * Debugging code for plotting structures commonly generated during fitting - * - **********************************************************************************/ - -// To plot specific groups of curves in MGED, do the following: -// set glob_compat_mode 0 -// set pl_list [glob 27_curve*.pl] -// foreach plfile $pl_list {overlay $plfile} -void plot_curve(struct rt_bot_internal *bot, std::vector<size_t> *pts, int r, int g, int b, FILE *c_plot) -{ - if (c_plot == NULL) { - FILE* plot = fopen("plot_curve.pl", "w"); - pl_color(plot, int(256*drand48() + 1.0), int(256*drand48() + 1.0), int(256*drand48() + 1.0)); - std::vector<size_t>::iterator v_it; - for (v_it = pts->begin(); v_it != pts->end()-1; v_it++) { - pdv_3move(plot, &bot->vertices[(*v_it)]); - pdv_3cont(plot, &bot->vertices[(*(v_it+1))]); - } - fclose(plot); - } else { - pl_color(c_plot, r, g, b); - std::vector<size_t>::iterator v_it; - for (v_it = pts->begin(); v_it != pts->end()-1; v_it++) { - pdv_3move(c_plot, &bot->vertices[(*v_it)]); - pdv_3cont(c_plot, &bot->vertices[(*(v_it+1))]); - } - } -} - -void plot_face(point_t p1, point_t p2, point_t p3, int r, int g, int b, FILE *c_plot) -{ - pl_color(c_plot, r, g, b); - pdv_3move(c_plot, p1); - pdv_3cont(c_plot, p2); - pdv_3move(c_plot, p1); - pdv_3cont(c_plot, p3); - pdv_3move(c_plot, p2); - pdv_3cont(c_plot, p3); -} - -void plot_faces(std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info, const char *filename) -{ - std::map< size_t, std::set<size_t> >::iterator p_it; - FILE* plot_file = fopen(filename, "w"); - for (p_it = patches->begin(); p_it != patches->end(); p_it++) { - int r = int(256*drand48() + 1.0); - int g = int(256*drand48() + 1.0); - int b = int(256*drand48() + 1.0); - std::set<size_t> *faces = &((*p_it).second); - std::set<size_t>::iterator f_it; - for (f_it = faces->begin(); f_it != faces->end(); f_it++) { - plot_face(&info->bot->vertices[info->bot->faces[(*f_it)*3+0]*3], &info->bot->vertices[info->bot->faces[(*f_it)*3+1]*3], &info->bot->vertices[info->bot->faces[(*f_it)*3+2]*3], r, g ,b, plot_file); - } - } - fclose(plot_file); -} - -void plot_patch_borders(std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info, const char *filename) -{ - std::map< size_t, std::set<size_t> >::iterator p_it; - FILE* edge_plot = fopen(filename, "w"); - pl_color(edge_plot, 255, 255, 255); - for (p_it = patches->begin(); p_it != patches->end(); p_it++) { - EdgeList patch_edges; - EdgeList::iterator e_it; - find_edge_segments(&((*p_it).second), &patch_edges, info); - for (e_it = patch_edges.begin(); e_it != patch_edges.end(); e_it++) { - pdv_3move(edge_plot, &info->bot->vertices[(*e_it).first]); - pdv_3cont(edge_plot, &info->bot->vertices[(*e_it).second]); - } - } - fclose(edge_plot); -} - -void plot_ncurve(ON_Curve &curve, FILE *c_plot) -{ - double pt1[3], pt2[3]; - ON_2dPoint from, to; - int plotres = 100; - if (curve.IsLinear()) { - int knotcnt = curve.SpanCount(); - double *knots = new double[knotcnt + 1]; - - curve.GetSpanVector(knots); - for (int i = 1; i <= knotcnt; i++) { - ON_3dPoint p = curve.PointAt(knots[i - 1]); - VMOVE(pt1, p); - p = curve.PointAt(knots[i]); - VMOVE(pt2, p); - pdv_3move(c_plot, pt1); - pdv_3cont(c_plot, pt2); - } - - } else { - ON_Interval dom = curve.Domain(); - // XXX todo: dynamically sample the curve - for (int i = 1; i <= plotres; i++) { - ON_3dPoint p = curve.PointAt(dom.ParameterAt((double)(i - 1) - / (double)plotres)); - VMOVE(pt1, p); - p = curve.PointAt(dom.ParameterAt((double) i / (double)plotres)); - VMOVE(pt2, p); - pdv_3move(c_plot, pt1); - pdv_3cont(c_plot, pt2); - } - } -} - -// plot loop -void plot_loop(std::vector<size_t> *edges, struct Manifold_Info *info, FILE *l_plot) -{ - std::vector<size_t>::iterator v_it; - int r = int(256*drand48() + 1.0); - int g = int(256*drand48() + 1.0); - int b = int(256*drand48() + 1.0); - for (v_it = edges->begin(); v_it != edges->end(); v_it++) { - pl_color(l_plot, r, g, b); - ON_BrepEdge& edge = info->brep->m_E[(int)(*v_it)]; - const ON_Curve* edge_curve = edge.EdgeCurveOf(); - ON_Interval dom = edge_curve->Domain(); - // XXX todo: dynamically sample the curve - int plotres = 50; - for (int i = 1; i <= plotres; i++) { - double pt1[3], pt2[3]; - ON_3dPoint p = edge_curve->PointAt(dom.ParameterAt((double)(i - 1) - / (double)plotres)); - VMOVE(pt1, p); - p = edge_curve->PointAt(dom.ParameterAt((double) i / (double)plotres)); - VMOVE(pt2, p); - pdv_3move(l_plot, pt1); - pdv_3cont(l_plot, pt2); - } - } -} - -/********************************************************************************** - * - * Code for partitioning a mesh into patches suitable for NURBS surface fitting - * - **********************************************************************************/ - -// Clean out empty patches -void remove_empty_patches(struct Manifold_Info *info) -{ - for (int i = 0; i < (int)info->patches.size(); i++) { - if (info->patches[i].size() == 0) { - info->patches.erase(i); - } - } -} - - -void sync_structure_maps(struct Manifold_Info *info) -{ - std::map< size_t, std::set<size_t> >::iterator p_it; - info->edge_to_patch.clear(); - info->vert_to_patch.clear(); - info->face_to_patch.clear(); - for (p_it = info->patches.begin(); p_it != info->patches.end(); p_it++) { - std::set<size_t>::iterator f_it; - std::set<size_t> *faces = &((*p_it).second); - for (f_it = faces->begin(); f_it != faces->end(); f_it++) { - info->face_to_patch[(*f_it)] = (*p_it).first; - std::set<Edge> face_edges; - std::set<Edge>::iterator face_edges_it; - get_face_edges(info->bot, (*f_it), &face_edges); - for (face_edges_it = face_edges.begin(); face_edges_it != face_edges.end(); face_edges_it++) { - info->edge_to_patch[(*face_edges_it)].insert((*p_it).first); - info->vert_to_patch[(*face_edges_it).first].insert((*p_it).first); - info->vert_to_patch[(*face_edges_it).second].insert((*p_it).first); - } - } - info->patch_to_plane[(*p_it).first] = info->face_to_plane[*(faces->begin())]; - } -} - -// For a given face, determine which patch shares the majority of its edges. If no one patch -// has a majority, return -1 -int find_major_patch(size_t face_num, struct Manifold_Info *info, size_t curr_patch, size_t patch_count) -{ - std::map<size_t, size_t> patch_cnt; - std::map<size_t, size_t>::iterator patch_cnt_itr; - std::set<size_t> connected_faces; - std::set<size_t>::iterator cf_it; - size_t max_patch = 0; - size_t max_patch_edge_cnt = 0; - get_connected_faces(info->bot, face_num, &(info->edge_to_face), &connected_faces); - for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { - patch_cnt[info->face_to_patch[*cf_it]] += 1; - } - for (patch_cnt_itr = patch_cnt.begin(); patch_cnt_itr != patch_cnt.end() ; patch_cnt_itr++) { - if ((*patch_cnt_itr).second > max_patch_edge_cnt) { - max_patch_edge_cnt = (*patch_cnt_itr).second; - max_patch = (*patch_cnt_itr).first; - } - } - if (max_patch_edge_cnt == 1) { - if (patch_count > 3) { - return -1; - } else { - // A patch with three or fewer triangles is considered a small patch - if one of the shared - // faces is a viable candidate, return it. - int candidate_patch = -1; - double candidate_patch_norm = 0; - for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { - if (info->face_to_patch[*cf_it] != curr_patch) { - double current_norm = info->norm_results[std::make_pair(face_num, info->patch_to_plane[info->face_to_patch[(*cf_it)]])]; - if (current_norm > candidate_patch_norm) { - candidate_patch = info->face_to_patch[(*cf_it)]; - candidate_patch_norm = current_norm; - } - } - } - return candidate_patch; - } - } else { - return (int)max_patch; - } -} - -// Given a list of edges and the "current" patch, find triangles that share more edges with -// a different patch. If the corresponding normals allow, move the triangles in question to -// the patch with which they share the most edges. Return the number of triangles shifted. -// This won't fully "smooth" an edge in a given pass, but an iterative approach should converge -// to edges with triangles in their correct "major" patches -size_t shift_edge_triangles(std::map< size_t, std::set<size_t> > *patches, size_t curr_patch, struct Manifold_Info *info) -{ - std::set<size_t> patch_edgefaces; - std::map<size_t, size_t> faces_to_shift; - std::map<size_t, size_t>::iterator f_it; - EdgeList edges; - EdgeList::iterator e_it; - std::set<size_t>::iterator sizet_it; - - // 0. Build edge set; - find_edge_segments(&((*patches)[curr_patch]), &edges, info); - - // 1. build triangle set of edge triangles in patch. - for (e_it = edges.begin(); e_it != edges.end(); e_it++) { - std::set<size_t> faces_from_edge = info->edge_to_face[(*e_it)]; - for (sizet_it = faces_from_edge.begin(); sizet_it != faces_from_edge.end() ; sizet_it++) { - if (info->face_to_patch[(*sizet_it)] == curr_patch) { - patch_edgefaces.insert((*sizet_it)); - } - } - - } - // 2. build triangle set of edge triangles with major patch other than current patch - // and a normal that permits movement to the major patch - for (sizet_it = patch_edgefaces.begin(); sizet_it != patch_edgefaces.end() ; sizet_it++) { - int major_patch = find_major_patch((*sizet_it), info, curr_patch, (*patches)[curr_patch].size()); - if (major_patch != (int)curr_patch && major_patch != -1) { - if (info->norm_results[std::make_pair((*sizet_it), info->patch_to_plane[major_patch])] >= 0) { - faces_to_shift[(*sizet_it)] = major_patch; - } - } - } - - // 3. move triangles to their major patch. - for (f_it = faces_to_shift.begin(); f_it != faces_to_shift.end(); f_it++) { - (*patches)[info->face_to_patch[(*f_it).first]].erase((*f_it).first); - (*patches)[(*f_it).second].insert((*f_it).first); - info->face_to_patch[(*f_it).first] = (*f_it).second; - } - - return faces_to_shift.size(); -} - -void construct_patches(std::set<size_t> *faces, std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info) { - if (faces->size() > 0){ - while(faces->size() > 0) { - info->patch_cnt++; - size_t new_patch = info->patch_cnt; - std::queue<size_t> face_queue; - face_queue.push((*faces->begin())); - faces->erase(face_queue.front()); - size_t start_face_num = face_queue.front(); - info->patch_to_plane[new_patch] = info->face_to_plane[face_queue.front()]; - while (!face_queue.empty()) { - size_t face_num = face_queue.front(); - face_queue.pop(); - (*patches)[new_patch].insert(face_num); - info->face_to_patch[face_num] = new_patch; - std::set<size_t> connected_faces; - std::set<size_t>::iterator cf_it; - get_connected_faces(info->bot, face_num, &(info->edge_to_face), &connected_faces); - for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { - if(faces->find((*cf_it)) != faces->end()) { - if(ON_DotProduct( *(*info).face_normals.At((int)(start_face_num)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { - face_queue.push((*cf_it)); - faces->erase((*cf_it)); -} - } - } - } - } - } -} - -void split_overlapping_patch(size_t face1, size_t face2, size_t orig_patch, std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info) { - std::set<size_t> *faces = &((*patches)[orig_patch]); - std::queue<size_t> face_queue_1; - std::queue<size_t> face_queue_2; - face_queue_1.push(*faces->find(face1)); - faces->erase(face_queue_1.front()); - info->patch_cnt++; - size_t new_patch_1 = info->patch_cnt; - size_t start_face_num_1 = face_queue_1.front(); - info->patch_to_plane[new_patch_1] = info->face_to_plane[face_queue_1.front()]; - face_queue_2.push(*faces->find(face2)); - faces->erase(face_queue_2.front()); - info->patch_cnt++; - size_t new_patch_2 = info->patch_cnt; - size_t start_face_num_2 = face_queue_2.front(); - info->patch_to_plane[new_patch_2] = info->face_to_plane[face_queue_2.front()]; - while (!face_queue_1.empty() || !face_queue_2.empty()) { - if (!face_queue_1.empty()) { - size_t face_num_1 = face_queue_1.front(); - face_queue_1.pop(); - (*patches)[new_patch_1].insert(face_num_1); - info->face_to_patch[face_num_1] = new_patch_1; - std::set<size_t> connected_faces; - std::set<size_t>::iterator cf_it; - get_connected_faces(info->bot, face_num_1, &(info->edge_to_face), &connected_faces); - for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { - if(faces->find((*cf_it)) != faces->end() && (*patches)[new_patch_2].find(*cf_it) == (*patches)[new_patch_2].end()) { - if(ON_DotProduct( *(*info).face_normals.At((int)(start_face_num_1)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { - face_queue_1.push((*cf_it)); - faces->erase((*cf_it)); - } - } - } - } - if (!face_queue_2.empty()) { - size_t face_num_2 = face_queue_2.front(); - face_queue_2.pop(); - (*patches)[new_patch_2].insert(face_num_2); - info->face_to_patch[face_num_2] = new_patch_2; - std::set<size_t> connected_faces; - std::set<size_t>::iterator cf_it; - get_connected_faces(info->bot, face_num_2, &(info->edge_to_face), &connected_faces); - for (cf_it = connected_faces.begin(); cf_it != connected_faces.end(); cf_it++) { - if(faces->find((*cf_it)) != faces->end() && (*patches)[new_patch_1].find(*cf_it) == (*patches)[new_patch_1].end()) { - if(ON_DotProduct( *(*info).face_normals.At(((int)start_face_num_2)),*(*info).face_normals.At((int)(*cf_it)) ) > 0.5) { - face_queue_2.push((*cf_it)); - faces->erase((*cf_it)); -} - } - } - } - } - if (faces->size() > 0) construct_patches(faces, patches, info); -} - -// Given a patch, find triangles that overlap when projected into the patch domain, remove them -// from the current patch and set them up in their own patch. Returns the number of faces moved -// from the current patch to their own patch. -// -// TODO - saw at least one case where triangle removal resulted one patch breaking into two -// topological patches. Need to handle this, otherwise Bad Things will happen when trying -// to generate BREPs. -// Also - need to check how the nurbs fitting code is calculating their initial plane, and use -// that for this test rather than the original faces - it is projection into *THAT* plane that -// must be clean, and a projection clean in the "standard" direction may not be clean there. -size_t overlapping_edge_triangles(std::map< size_t, std::set<size_t> > *patches, struct Manifold_Info *info) -{ - size_t total_overlapping = 0; - std::map< size_t, std::set<size_t> >::iterator p_it; - for (p_it = patches->begin(); p_it != patches->end(); p_it++) { - if ((*p_it).second.size() > 0) { - ON_Plane plane; - fit_plane((*p_it).first, &((*p_it).second), info, &plane); - ON_Xform xf; - xf.PlanarProjection(plane); - size_t overlap_cnt = 1; - size_t patch_overlapping = 0; - while (overlap_cnt != 0) { - std::set<size_t> edge_triangles; - EdgeList edges; - find_edge_segments(&((*p_it).second), &edges, info); - EdgeList::iterator e_it; - std::set<size_t>::iterator sizet_it; - // 1. build triangle set of edge triangles in patch. - for (e_it = edges.begin(); e_it != edges.end(); e_it++) { - std::set<size_t> faces_from_edge = info->edge_to_face[(*e_it)]; - for (sizet_it = faces_from_edge.begin(); sizet_it != faces_from_edge.end() ; sizet_it++) { - if (info->face_to_patch[(*sizet_it)] == (*p_it).first) { - edge_triangles.insert((*sizet_it)); - } - } - } - // 2. Find an overlapping triangle, remove it to its own patch, fix the edges, continue - overlap_cnt = 0; - for (sizet_it = edge_triangles.begin(); sizet_it != edge_triangles.end() ; sizet_it++) { - point_t v0, v1, v2; - ON_3dPoint onpt_v0(&info->bot->vertices[info->bot->faces[(*sizet_it)*3+0]*3]); - ON_3dPoint onpt_v1(&info->bot->vertices[info->bot->faces[(*sizet_it)*3+1]*3]); - ON_3dPoint onpt_v2(&info->bot->vertices[info->bot->faces[(*sizet_it)*3+2]*3]); - onpt_v0.Transform(xf); - onpt_v1.Transform(xf); - onpt_v2.Transform(xf); - VSET(v0, onpt_v0.x, onpt_v0.y, onpt_v0.z); - VSET(v1, onpt_v1.x, onpt_v1.y, onpt_v1.z); - VSET(v2, onpt_v2.x, onpt_v2.y, onpt_v2.z); - edge_triangles.erase(*sizet_it); - std::set<size_t>::iterator ef_it2 = edge_triangles.begin(); - for (ef_it2 = edge_triangles.begin(); ef_it2!=edge_triangles.end(); ef_it2++) { - if ((*sizet_it) != (*ef_it2)) { - point_t u0, u1, u2; - ON_3dPoint onpt_u0(&info->bot->vertices[info->bot->faces[(*ef_it2)*3+0]*3]); - ON_3dPoint onpt_u1(&info->bot->vertices[info->bot->faces[(*ef_it2)*3+1]*3]); - ON_3dPoint onpt_u2(&info->bot->vertices[info->bot->faces[(*ef_it2)*3+2]*3]); - onpt_u0.Transform(xf); - onpt_u1.Transform(xf); - onpt_u2.Transform(xf); - VSET(u0, onpt_u0.x, onpt_u0.y, onpt_u0.z); - VSET(u1, onpt_u1.x, onpt_u1.y, onpt_u1.z); - VSET(u2, onpt_u2.x, onpt_u2.y, onpt_u2.z); - int overlap = bn_coplanar_tri_tri_isect(v0, v1, v2, u0, u1, u2, 1); - if (overlap) { - std::cout << "Patch " << (*p_it).first << " overlap: (" << *sizet_it << "," << *ef_it2 << ")\n"; - split_overlapping_patch(*sizet_it, *ef_it2, (*p_it).first, patches, info); -#if 0 - info->patch_cnt++; - size_t new_patch = info->patch_cnt; - (*patches)[new_patch].insert(*sizet_it); - (*patches)[(*p_it).first].erase(*sizet_it); - info->patch_to_plane[new_patch] = info->face_to_plane[*sizet_it]; - info->face_to_patch[*sizet_it] = new_patch; - find_edge_segments(&((*p_it).second), &edges, info); -#endif - overlap_cnt++; - patch_overlapping++; - total_overlapping++; - } - } - if (overlap_cnt > 0) break; - } - if (overlap_cnt > 0) break; - } - } -// verify_patch_integrity((*p_it).first, &((*p_it).second), patches, info); - } - } - return total_overlapping; -} - -void bot_partition(struct Manifold_Info *info) -{ - std::map< size_t, std::set<size_t> > face_groups; - std::map< size_t, std::set<size_t> > patches; - // Calculate face normals dot product with bounding rpp planes - for (size_t i=0; i < info->bot->num_faces; ++i) { - size_t pt_A, pt_B, pt_C; - size_t result_max; - double vdot = 0.0; - double result = 0.0; - vect_t a, b, norm_dir; - // Add vert -> edge and edge -> face mappings to global map. - pt_A = info->bot->faces[i*3+0]*3; - pt_B = info->bot->faces[i*3+1]*3; - pt_C = info->bot->faces[i*3+2]*3; - info->edge_to_face[mk_edge(pt_A, pt_B)].insert(i); - info->edge_to_face[mk_edge(pt_B, pt_C)].insert(i); - info->edge_to_face[mk_edge(pt_C, pt_A)].insert(i); - // Categorize face - VSUB2(a, &info->bot->vertices[info->bot->faces[i*3+1]*3], &info->bot->vertices[info->bot->faces[i*3]*3]); - VSUB2(b, &info->bot->vertices[info->bot->faces[i*3+2]*3], &info->bot->vertices[info->bot->faces[i*3]*3]); - VCROSS(norm_dir, a, b); - VUNITIZE(norm_dir); - info->face_normals.Append(ON_3dVector(norm_dir[0], norm_dir[1], norm_dir[2])); - (*info).face_normals.At((int)i)->Unitize(); - for (size_t j=0; j < (size_t)(*info).vectors.Count(); j++) { - vdot = ON_DotProduct(*(*info).vectors.At((int)j), *(*info).face_normals.At((int)i)); - info->norm_results[std::make_pair(i, j)] = vdot; - if (vdot > result) { - result_max = j; - result = vdot; - } - } - face_groups[result_max].insert(i); - info->face_to_plane[i]=result_max; - } - // Sort the groups by their face count - we want to start with the group containing - // either the least or the most faces - try most. - std::map< size_t, std::set<size_t> >::iterator fg_it; - std::vector<size_t> ordered_vects((*info).vectors.Count()); - std::set<int> face_group_set; - for (int i = 0; i < (*info).vectors.Count(); i++) { - face_group_set.insert(i); - } - size_t array_pos = 0; - while (!face_group_set.empty()) { - size_t curr_max = 0; - size_t curr_vect = 0; - for (fg_it = face_groups.begin(); fg_it != face_groups.end(); fg_it++) { - if ((*fg_it).second.size() > curr_max) { - if (face_group_set.find((*fg_it).first) != face_group_set.end()) { - curr_max = (*fg_it).second.size(); - curr_vect = (*fg_it).first; - } - } - } - ordered_vects.at(array_pos) = curr_vect; - face_group_set.erase(curr_vect); - array_pos++; - } - - // All faces must belong to some patch - continue until all faces are processed - for (int i = 0; i < 6; i++) { - fg_it = face_groups.find(ordered_vects.at(i)); - std::set<size_t> *faces = &((*fg_it).second); - while (!faces->empty()) { - info->patch_cnt++; - // Find largest remaining face in group - double face_size_criteria = 0.0; - size_t smallest_face = 0; - for (std::set<size_t>::iterator fgl_it = faces->begin(); fgl_it != faces->end(); fgl_it++) { - double fa = face_area(info->bot, *fgl_it); - if (fa > face_size_criteria) { - smallest_face = (*fgl_it); - face_size_criteria = fa; - } - } - std::queue<size_t> face_queue; - FaceList::iterator f_it; - face_queue.push(smallest_face); - face_groups[info->face_to_plane[face_queue.front()]].erase(face_queue.front()); - size_t current_plane = info->face_to_plane[face_queue.front()]; - //size_t start_face_num = face_queue.front(); - while (!face_queue.empty()) { - size_t face_num = face_queue.front(); - face_queue.pop(); - patches[info->patch_cnt].insert(face_num); - info->patch_to_plane[info->patch_cnt] = current_plane; - info->face_to_patch[face_num] = info->patch_cnt; - - std::set<size_t> connected_faces; - std::set<size_t>::iterator cf_it; - get_connected_faces(info->bot, face_num, &(info->edge_to_face), &connected_faces); - for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { - double curr_face_area = face_area(info->bot, (*cf_it)); - if (curr_face_area < (face_size_criteria*10) && curr_face_area > (face_size_criteria*0.1)) { - if (face_groups[info->face_to_plane[(*cf_it)]].find((*cf_it)) != face_groups[info->face_to_plane[(*cf_it)]].end()) { - if (info->face_to_plane[(*cf_it)] == current_plane) { - // if(ON_DotProduct( *(*info).face_normals.At((start_face_num)),*(*info).face_normals.At((*cf_it)) ) > 0.5) { - // Large patches pose a problem for feature preservation - make an attempt to ensure "large" - // patches are flat. - if (patches[info->patch_cnt].size() > info->patch_size_threshold) { - vect_t origin; - size_t ok = 1; - VMOVE(origin, &info->bot->vertices[info->bot->faces[(face_num)*3]*3]); - ON_Plane plane(ON_3dPoint(origin[0], origin[1], origin[2]), *(*info).face_normals.At((int)(face_num))); - for (int pt = 0; pt < 3; pt++) { - point_t cpt; - VMOVE(cpt, &info->bot->vertices[info->bot->faces[((*cf_it))*3+pt]*3]); - double dist_to_plane = plane.DistanceTo(ON_3dPoint(cpt[0], cpt[1], cpt[2])); - //std::cout << "Distance[" << face_num << "," << (*cf_it) << "](" << pt << "): " << dist_to_plane << "\n"; - if (dist_to_plane > 0) { - double dist = DIST_PT_PT(origin, cpt); - double angle = atan(dist_to_plane/dist); - if (angle > info->neighbor_angle_threshold) ok = 0; - } - } - if (ok) { - face_queue.push((*cf_it)); - face_groups[info->face_to_plane[(*cf_it)]].erase((*cf_it)); - } - } else { - face_queue.push((*cf_it)); - face_groups[info->face_to_plane[(*cf_it)]].erase((*cf_it)); - } - // } - } - } - } - } - } - } - } - - // Find "interior" patches and see if they can be merged with the parent patch - - - // "Shave" sharp triangles off of the edges by shifting them from one patch to - // another - doesn't avoid all sharp corners, but does produce some cleanup. - - std::map< size_t, std::set<size_t> >::iterator p_it; - size_t shaved_cnt = 1; - size_t edge_smoothing_count = 0; - while (shaved_cnt != 0 && edge_smoothing_count <= 20) { - shaved_cnt = 0; - edge_smoothing_count++; - for (p_it = patches.begin(); p_it != patches.end(); p_it++) { - shaved_cnt += shift_edge_triangles(&patches, (*p_it).first, info); - } - std::cout << "Triangle shifts in smoothing pass " << edge_smoothing_count << ": " << shaved_cnt << "\n"; - } - - // Identify triangles that overlap in the patches associated high-level planar projection, and - // assign them to their own patches - they pose a problem for surface fitting if left in the - // original overlapping patches. - size_t overlapping_face_cnt = 0; - overlapping_face_cnt = overlapping_edge_triangles(&patches, info); - std::cout << "Found " << overlapping_face_cnt << " overlapping faces in projection\n"; - - // now, populate &(info->patches) with the non-empty patches and fix *_to_patch (maybe make that - // part of sync_structure_maps. - std::ofstream patch_map; - patch_map.open("patch_map.txt"); - for (p_it = patches.begin(); p_it != patches.end(); p_it++) { - if (patches[(*p_it).first].size() > 0) { - patch_map << (*p_it).first << " -> " << info->patches.size() << "\n"; - info->patches[info->patches.size()].insert(patches[(*p_it).first].begin(), patches[(*p_it).first].end()); - } - } - patch_map.close(); - - std::cout << "Patch count: " << info->patches.size() << "\n"; - plot_faces(&(info->patches), info, "patches.pl"); - plot_patch_borders(&(info->patches), info, "patch_borders.pl"); - - // Now that the mesh is fully partitioned, build the maps needed for curve discovery - sync_structure_maps(info); -} - -/********************************************************************************** - * - * Code for moving from patches with edge segments to a structured topology - * of curve segments and loops. - * - **********************************************************************************/ -void find_edges(struct Manifold_Info *info) -{ - std::map< size_t, size_t> vert_to_m_V; // Keep mapping between vertex index being used in Brep and BoT index - std::map< size_t, std::set<size_t> >::iterator p_it; - std::map< size_t, EdgeList > all_patch_edges; - for (p_it = info->patches.begin(); p_it != info->patches.end(); p_it++) { - if (!info->patches[(*p_it).first].empty()) { - find_edge_segments(&((*p_it).second), &(all_patch_edges[(*p_it).first]), info); - } - } - FILE* pcurveplot = fopen("polycurves.pl", "w"); - FILE *nurbs_curves = fopen("nurbs_curves.pl", "w"); - FILE *curves_plot = fopen("curves.pl", "w"); - for (p_it = info->patches.begin(); p_it != info->patches.end(); p_it++) { - if (!info->patches[(*p_it).first].empty()) { - EdgeList *patch_edges = &(all_patch_edges[(*p_it).first]); - while (!patch_edges->empty()) { - // We know the current patch - find out what the other one is for - // this edge. - const Edge *first_edge = &(*(patch_edges->begin())); - std::set<size_t> edge_patches = (*(info->edge_to_patch.find(*first_edge))).second; - edge_patches.erase((*p_it).first); - size_t other_patch_id = *(edge_patches.begin()); - // Now we know our patches - we need to start with the first line - // segment, and build up a set of edges until one of the halting - // criteria is met. - std::set<Edge> polycurve_edges; @@ Diff output truncated at 100000 characters. @@ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54241] brlcad/trunk/src/librt From: <starseeker@us...> - 2013-01-30 23:06 Revision: 54241 http://brlcad.svn.sourceforge.net/brlcad/?rev=54241&view=rev Author: starseeker Date: 2013-01-30 23:06:36 +0000 (Wed, 30 Jan 2013) Log Message: ----------- Add more headers to test files Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt brlcad/trunk/src/librt/test_bot2nurbs.cpp brlcad/trunk/src/librt/test_root3-subd.cpp Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2013-01-30 23:02:46 UTC (rev 54240) +++ brlcad/trunk/src/librt/CMakeLists.txt 2013-01-30 23:06:36 UTC (rev 54241) @@ -250,8 +250,8 @@ librt_private.h namegen.c test_nurbsfit.cpp - test_botpatches.cpp - test_subdivision.cpp + test_bot2nurbs.cpp + test_root3-subd.cpp subd_test_bot.asc prcomb.c primitives/bot/btg.h @@ -306,9 +306,9 @@ ${CMAKE_CURRENT_SOURCE_DIR}/../libnurbs ) -#BRLCAD_ADDEXEC(test_botpatches test_botpatches.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) +#BRLCAD_ADDEXEC(test_bot2nurbs test_bot2nurbs.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) #BRLCAD_ADDEXEC(test_nurbsfit test_nurbsfit.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) -#BRLCAD_ADDEXEC(test_subdivision test_subdivision.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) +#BRLCAD_ADDEXEC(test_root3-subd test_root3-subd.cpp "librt;libwdb;libnurbs;libbu" NOSTRICT NO_INSTALL) BRLCAD_ADDEXEC(test_dvec test_dvec.cpp "librt" NOSTRICT NO_INSTALL LOCAL) ADD_TEST(test_dvec test_dvec) Modified: brlcad/trunk/src/librt/test_bot2nurbs.cpp =================================================================== --- brlcad/trunk/src/librt/test_bot2nurbs.cpp 2013-01-30 23:02:46 UTC (rev 54240) +++ brlcad/trunk/src/librt/test_bot2nurbs.cpp 2013-01-30 23:06:36 UTC (rev 54241) @@ -1,3 +1,31 @@ +/* T E S T _ B O T 2 N U R B S . C P P + * BRL-CAD + * + * Copyright (c) 2013 United States Government as represented by + * the U.S. Army Research Laboratory. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * version 2.1 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this file; see the file named COPYING for more + * information. + */ +/** @file test_bot2nurbs.cpp + * + * This file contains the logic that takes an input BoT, breaks that + * BoT down into patches, fits surfaces to those patches, builds + * trimming loops for the surfaces based on NURBS curves fitted to + * patch edge segments, and assembles the result into a closed BREP. + * + */ + /* TODO - Can't keep shifting the fitting plane for a triangle patch * every time a triangle is added - too computationally expensive. * Instead, need to make sure that the starting plane used for the Modified: brlcad/trunk/src/librt/test_root3-subd.cpp =================================================================== --- brlcad/trunk/src/librt/test_root3-subd.cpp 2013-01-30 23:02:46 UTC (rev 54240) +++ brlcad/trunk/src/librt/test_root3-subd.cpp 2013-01-30 23:06:36 UTC (rev 54241) @@ -1,3 +1,28 @@ +/* T E S T _ R O O T 3 - S U B D . C P P + * BRL-CAD + * + * Copyright (c) 2013 United States Government as represented by + * the U.S. Army Research Laboratory. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * version 2.1 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this file; see the file named COPYING for more + * information. + */ +/** @file test_root3-subd.cpp + * + * Brief description + * + */ + #include "common.h" #include <map> This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54536] brlcad/trunk/src/librt From: <brlcad@us...> - 2013-03-06 19:55 Revision: 54536 http://brlcad.svn.sourceforge.net/brlcad/?rev=54536&view=rev Author: brlcad Date: 2013-03-06 19:54:55 +0000 (Wed, 06 Mar 2013) Log Message: ----------- remove the pooling on geometry objects at the IO layer. testing of the pooling calls indicated performance was substantially slower than system malloc/free (by an order of magnitude). Modified Paths: -------------- brlcad/trunk/src/librt/db5_io.c brlcad/trunk/src/librt/db5_scan.c Modified: brlcad/trunk/src/librt/db5_io.c =================================================================== --- brlcad/trunk/src/librt/db5_io.c 2013-03-06 17:33:47 UTC (rev 54535) +++ brlcad/trunk/src/librt/db5_io.c 2013-03-06 19:54:55 UTC (rev 54536) @@ -361,11 +361,7 @@ } /* Now that we finally know how large the object is, get it all */ -#if 1 - rip->buf = (unsigned char *)bu_pool_get((size_t)rip->object_length); -#else rip->buf = (unsigned char *)bu_malloc(rip->object_length, "raw v5 object"); -#endif *((struct db5_ondisk_header *)rip->buf) = header; /* struct copy */ memcpy(rip->buf+sizeof(header), lenbuf, count); Modified: brlcad/trunk/src/librt/db5_scan.c =================================================================== --- brlcad/trunk/src/librt/db5_scan.c 2013-03-06 17:33:47 UTC (rev 54535) +++ brlcad/trunk/src/librt/db5_scan.c 2013-03-06 19:54:55 UTC (rev 54536) @@ -92,11 +92,7 @@ (*handler)(dbip, &raw, addr, client_data); nrec++; if (raw.buf) { -#if 1 - bu_pool_put((void *)raw.buf, (size_t)raw.object_length); -#else bu_free(raw.buf, "raw v5 object"); -#endif raw.buf = NULL; } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54722] brlcad/trunk/src/librt From: <brlcad@us...> - 2013-03-19 04:14 Revision: 54722 http://brlcad.svn.sourceforge.net/brlcad/?rev=54722&view=rev Author: brlcad Date: 2013-03-19 04:14:23 +0000 (Tue, 19 Mar 2013) Log Message: ----------- pointers returned to the caller should be allocated via BU_ALLOC/bu_*alloc so we can define consistent API, change from BU_GET Modified Paths: -------------- brlcad/trunk/src/librt/db_anim.c brlcad/trunk/src/librt/db_inmem.c brlcad/trunk/src/librt/db_open.c brlcad/trunk/src/librt/db_tree.c Modified: brlcad/trunk/src/librt/db_anim.c =================================================================== --- brlcad/trunk/src/librt/db_anim.c 2013-03-19 04:11:30 UTC (rev 54721) +++ brlcad/trunk/src/librt/db_anim.c 2013-03-19 04:14:23 UTC (rev 54722) @@ -264,7 +264,7 @@ return (struct animate *)NULL; } - BU_GET(anp, struct animate); + BU_ALLOC(anp, struct animate); anp->magic = ANIMATE_MAGIC; db_init_db_tree_state(&ts, dbip, &rt_uniresource); Modified: brlcad/trunk/src/librt/db_inmem.c =================================================================== --- brlcad/trunk/src/librt/db_inmem.c 2013-03-19 04:11:30 UTC (rev 54721) +++ brlcad/trunk/src/librt/db_inmem.c 2013-03-19 04:14:23 UTC (rev 54722) @@ -51,7 +51,7 @@ register struct db_i *dbip = DBI_NULL; register int i; - BU_GET(dbip, struct db_i); + BU_ALLOC(dbip, struct db_i); dbip->dbi_eof = (off_t)-1L; dbip->dbi_fp = NULL; dbip->dbi_mf = NULL; Modified: brlcad/trunk/src/librt/db_open.c =================================================================== --- brlcad/trunk/src/librt/db_open.c 2013-03-19 04:11:30 UTC (rev 54721) +++ brlcad/trunk/src/librt/db_open.c 2013-03-19 04:14:23 UTC (rev 54722) @@ -115,7 +115,7 @@ return dbip; } - BU_GET(dbip, struct db_i); + BU_ALLOC(dbip, struct db_i); dbip->dbi_mf = mfp; dbip->dbi_eof = (off_t)mfp->buflen; dbip->dbi_inmem = mfp->buf; @@ -134,7 +134,7 @@ } else { /* Read-write mode */ - BU_GET(dbip, struct db_i); + BU_ALLOC(dbip, struct db_i); dbip->dbi_eof = (off_t)-1L; if ((dbip->dbi_fp = fopen(name, "r+b")) == NULL) { Modified: brlcad/trunk/src/librt/db_tree.c =================================================================== --- brlcad/trunk/src/librt/db_tree.c 2013-03-19 04:11:30 UTC (rev 54721) +++ brlcad/trunk/src/librt/db_tree.c 2013-03-19 04:14:23 UTC (rev 54722) @@ -118,7 +118,7 @@ RT_CK_FULL_PATH(pathp); RT_CK_DBI(tsp->ts_dbip); - BU_GET(new_ctsp, struct combined_tree_state); + BU_ALLOC(new_ctsp, struct combined_tree_state); new_ctsp->magic = RT_CTS_MAGIC; db_dup_db_tree_state(&(new_ctsp->cts_s), tsp); db_full_path_init(&(new_ctsp->cts_p)); @@ -136,7 +136,7 @@ struct combined_tree_state *new_ctsp; RT_CK_CTS(old_ctsp); - BU_GET(new_ctsp, struct combined_tree_state); + BU_ALLOC(new_ctsp, struct combined_tree_state); new_ctsp->magic = RT_CTS_MAGIC; db_dup_db_tree_state(&(new_ctsp->cts_s), &(old_ctsp->cts_s)); db_full_path_init(&(new_ctsp->cts_p)); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[54747] brlcad/trunk/src/librt From: <brlcad@us...> - 2013-03-20 14:05 Revision: 54747 http://brlcad.svn.sourceforge.net/brlcad/?rev=54747&view=rev Author: brlcad Date: 2013-03-20 14:04:55 +0000 (Wed, 20 Mar 2013) Log Message: ----------- returned to caller or otherwised released elsewhere, so call BU_ALLOC() Modified Paths: -------------- brlcad/trunk/src/librt/shoot.c brlcad/trunk/src/librt/tol.c brlcad/trunk/src/librt/tree.c brlcad/trunk/src/librt/vlist.c brlcad/trunk/src/librt/vshoot.c Modified: brlcad/trunk/src/librt/shoot.c =================================================================== --- brlcad/trunk/src/librt/shoot.c 2013-03-20 14:01:10 UTC (rev 54746) +++ brlcad/trunk/src/librt/shoot.c 2013-03-20 14:04:55 UTC (rev 54747) @@ -600,7 +600,7 @@ case CUT_NUGRIDNODE: { struct rt_shootray_status *old; - BU_GET(old, struct rt_shootray_status); + BU_ALLOC(old, struct rt_shootray_status); *old = *ssp; /* struct copy */ /* Descend into node */ @@ -965,7 +965,7 @@ solidbits = rt_get_solidbitv(rtip->nsolids, resp); if (BU_LIST_IS_EMPTY(&resp->re_region_ptbl)) { - BU_GET(regionbits, struct bu_ptbl); + BU_ALLOC(regionbits, struct bu_ptbl); bu_ptbl_init(regionbits, 7, "rt_shootray() regionbits ptbl"); } else { regionbits = BU_LIST_FIRST(bu_ptbl, &resp->re_region_ptbl); Modified: brlcad/trunk/src/librt/tol.c =================================================================== --- brlcad/trunk/src/librt/tol.c 2013-03-20 14:01:10 UTC (rev 54746) +++ brlcad/trunk/src/librt/tol.c 2013-03-20 14:04:55 UTC (rev 54747) @@ -25,7 +25,7 @@ rt_tol_default(struct bn_tol *tol) { if (!tol) { - BU_GET(tol, struct bn_tol); + BU_ALLOC(tol, struct bn_tol); BN_TOL_INIT(tol); } Modified: brlcad/trunk/src/librt/tree.c =================================================================== --- brlcad/trunk/src/librt/tree.c 2013-03-20 14:01:10 UTC (rev 54746) +++ brlcad/trunk/src/librt/tree.c 2013-03-20 14:04:55 UTC (rev 54747) @@ -160,7 +160,7 @@ return curtree; } - BU_GET(rp, struct region); + BU_ALLOC(rp, struct region); rp->l.magic = RT_REGION_MAGIC; rp->reg_regionid = tsp->ts_regionid; rp->reg_is_fastgen = tsp->ts_is_fastgen; @@ -386,7 +386,7 @@ * now, while still inside the critical section, because they are * searched on, above. */ - BU_GET(stp, struct soltab); + BU_ALLOC(stp, struct soltab); stp->l.magic = RT_SOLTAB_MAGIC; stp->l2.magic = RT_SOLTAB2_MAGIC; stp->st_rtip = rtip; Modified: brlcad/trunk/src/librt/vlist.c =================================================================== --- brlcad/trunk/src/librt/vlist.c 2013-03-20 14:01:10 UTC (rev 54746) +++ brlcad/trunk/src/librt/vlist.c 2013-03-20 14:04:55 UTC (rev 54747) @@ -45,7 +45,7 @@ if (!BU_LIST_IS_INITIALIZED(free_vlist_hd)) BU_LIST_INIT(free_vlist_hd); - BU_GET(vbp, struct bn_vlblock); + BU_ALLOC(vbp, struct bn_vlblock); vbp->magic = BN_VLBLOCK_MAGIC; vbp->free_vlist_hd = free_vlist_hd; vbp->max = max_ent; Modified: brlcad/trunk/src/librt/vshoot.c =================================================================== --- brlcad/trunk/src/librt/vshoot.c 2013-03-20 14:01:10 UTC (rev 54746) +++ brlcad/trunk/src/librt/vshoot.c 2013-03-20 14:04:55 UTC (rev 54747) @@ -174,7 +174,7 @@ solidbits = rt_get_solidbitv(rtip->nsolids, ap->a_resource); if (BU_LIST_IS_EMPTY(&ap->a_resource->re_region_ptbl)) { - BU_GET(regionbits, struct bu_ptbl); + BU_ALLOC(regionbits, struct bu_ptbl); bu_ptbl_init(regionbits, 7, "rt_shootray() regionbits ptbl"); } else { regionbits = BU_LIST_FIRST(bu_ptbl, &ap->a_resource->re_region_ptbl); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[55183] brlcad/trunk/src/librt From: <starseeker@us...> - 2013-04-18 20:51 Revision: 55183 http://brlcad.svn.sourceforge.net/brlcad/?rev=55183&view=rev Author: starseeker Date: 2013-04-18 20:51:30 +0000 (Thu, 18 Apr 2013) Log Message: ----------- Add test case for get_closest_point, using an isolated surface and two 3D inputs that are unexpectedly returning the same 2D pullback result. Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt Added Paths: ----------- brlcad/trunk/src/librt/tests/ brlcad/trunk/src/librt/tests/CMakeLists.txt brlcad/trunk/src/librt/tests/nurbs_surfaces.g brlcad/trunk/src/librt/tests/nurbs_tests.cpp Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2013-04-18 19:41:41 UTC (rev 55182) +++ brlcad/trunk/src/librt/CMakeLists.txt 2013-04-18 20:51:30 UTC (rev 55183) @@ -313,10 +313,13 @@ #BRLCAD_ADDEXEC(test_bot2nurbs test_bot2nurbs.cpp "librt;libwdb;libbrep;libbu" NOSTRICT NO_INSTALL) #BRLCAD_ADDEXEC(test_nurbsfit test_nurbsfit.cpp "librt;libwdb;libbrep;libbu" NOSTRICT NO_INSTALL) #BRLCAD_ADDEXEC(test_root3-subd test_root3-subd.cpp "librt;libwdb;libbrep;libbu" NOSTRICT NO_INSTALL) +#BRLCAD_ADDEXEC(test_surfacetree test_surfacetree.cpp "librt;libwdb;libbrep;libbu" NOSTRICT NO_INSTALL) BRLCAD_ADDEXEC(test_dvec test_dvec.cpp "librt" NOSTRICT NO_INSTALL LOCAL) ADD_TEST(test_dvec test_dvec) +add_subdirectory(tests) + # Local Variables: # tab-width: 8 # mode: cmake Added: brlcad/trunk/src/librt/tests/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/tests/CMakeLists.txt (rev 0) +++ brlcad/trunk/src/librt/tests/CMakeLists.txt 2013-04-18 20:51:30 UTC (rev 55183) @@ -0,0 +1,12 @@ +BRLCAD_ADDEXEC(nurbs_tester nurbs_tests.cpp "librt;libbrep;libbu" NO_INSTALL LOCAL) + +add_test(get_closest_point-distinct_points nurbs_tester ${CMAKE_CURRENT_SOURCE_DIR}/nurbs_surfaces.g 1) + +CMAKEFILES(nurbs_surfaces.g) + +# Local Variables: +# tab-width: 8 +# mode: cmake +# indent-tabs-mode: t +# End: +# ex: shiftwidth=2 tabstop=8 textwidth=0 wrapmargin=0 Property changes on: brlcad/trunk/src/librt/tests/CMakeLists.txt ___________________________________________________________________ Added: svn:mime-type + text/plain Added: svn:eol-style + native Added: brlcad/trunk/src/librt/tests/nurbs_surfaces.g =================================================================== (Binary files differ) Property changes on: brlcad/trunk/src/librt/tests/nurbs_surfaces.g ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Added: brlcad/trunk/src/librt/tests/nurbs_tests.cpp =================================================================== --- brlcad/trunk/src/librt/tests/nurbs_tests.cpp (rev 0) +++ brlcad/trunk/src/librt/tests/nurbs_tests.cpp 2013-04-18 20:51:30 UTC (rev 55183) @@ -0,0 +1,139 @@ +#include "common.h" + +#include <cstdlib> +#include <cstdio> +#include <cstring> +#include <limits> +#include <iomanip> + +#include "brep.h" +#include "raytrace.h" + + +int +get_surface(const char *name, struct db_i *dbip, struct rt_db_internal *intern, struct rt_brep_internal **brep_ip) { + + struct directory *dp; + (*brep_ip) = NULL; + + + dp = db_lookup(dbip, name, LOOKUP_QUIET); + if (dp == RT_DIR_NULL) { + bu_log("ERROR: Unable to look up object %s\n", name); + return -1; + } + + if (rt_db_get_internal(intern, dp, dbip, NULL, &rt_uniresource) < 0) { + bu_log("ERROR: Unable to get internal representation of %s\n", name); + return -1; + } + + if (intern->idb_minor_type != DB5_MINORTYPE_BRLCAD_BREP) { + bu_log("ERROR: object %s does not appear to be of type BRep\n", name); + return -1; + } else { + (*brep_ip) = (struct rt_brep_internal *)(intern->idb_ptr); + } + + RT_BREP_CK_MAGIC(*brep_ip); + return 0; +} + +int +nurbs_test(long int test_number, struct db_i *dbip) +{ + /* Have various specific surface structures - there are potentially + * multiple surfaces in the .g, but multiple tests may re-use a single + * surface.*/ + + /* openNURBS pointers */ + ON_Brep *brep = NULL; + + switch (test_number) + { + case 1: /* 3d -> 2d pull-back function get_closest_point */ + { + struct rt_db_internal case_1_intern; + struct rt_brep_internal *case_1_brep_ip = NULL; + RT_DB_INTERNAL_INIT(&case_1_intern); + if (get_surface("case_1_surface.s", dbip, &case_1_intern, &case_1_brep_ip)) return -1; + brep = case_1_brep_ip->brep; + ON_BrepFace& c1_face = brep->m_F[0]; + brlcad::SurfaceTree* c1_st = new brlcad::SurfaceTree(&c1_face, false); + + ON_2dPoint pt_2d_1, pt_2d_2; + ON_3dPoint pt_3d_1(11204.05366897583,-16726.489562988281, 3358.7263298034668); + ON_3dPoint pt_3d_2(11204.007682800293, -16726.479568481445, 3358.8327312469482); + (void)get_closest_point(pt_2d_1, &c1_face, pt_3d_1, c1_st); + (void)get_closest_point(pt_2d_2, &c1_face, pt_3d_2, c1_st); + rt_db_free_internal(&case_1_intern); + delete c1_st; + if (pt_2d_1 == pt_2d_2) { + std::cout << "NURBS test case 1 failure (get_closest_point): Unexpectedly identical 2D pullbacks from different 3D points\n"; + std::cout << std::setprecision(std::numeric_limits<double>::digits10) << "Inputs: 3d Point 1: " << pt_3d_1.x << "," << pt_3d_1.y << "," << pt_3d_1.z << "\n"; + std::cout << std::setprecision(std::numeric_limits<double>::digits10) << " 3d Point 2: " << pt_3d_2.x << "," << pt_3d_2.y << "," << pt_3d_2.z << "\n"; + std::cout << std::setprecision(std::numeric_limits<double>::digits10) << "Output: 2d Point 1: " << pt_2d_1.x << "," << pt_2d_1.y << "\n"; + std::cout << std::setprecision(std::numeric_limits<double>::digits10) << " 2d Point 2: " << pt_2d_2.x << "," << pt_2d_2.y << "\n"; + return -1; + } + return 0; + } + default: + return -1; + } + +} + + +int +main(int argc, char **argv) +{ + long int test_number = 0; + int retval = 0; + long int all_tests = 1; + struct db_i *dbip; + char *endptr; + + /* Set up the .g file */ + if (argc > 3 || argc < 2) { + bu_log("Usage: %s file.g [test_number]", argv[0]); + return -1; + } + + dbip = db_open(argv[1], "r+w"); + if (dbip == DBI_NULL) { + bu_log("ERROR: Unable to read from %s\n", argv[1]); + return -1; + } + + if (db_dirbuild(dbip) < 0){ + bu_log("ERROR: Unable to read from %s\n", argv[1]); + return -1; + } + + if (argc == 3) { + test_number = strtol(argv[2], &endptr, 10); + if (*endptr) return -1; + } + + if (!test_number) { + int current_test = 1; + while (current_test <= all_tests && retval != -1) { + retval = nurbs_test(current_test, dbip); + current_test++; + } + } else { + retval = nurbs_test(test_number, dbip); + } + return retval; +} + +/* + * Local Variables: + * mode: C + * tab-width: 8 + * indent-tabs-mode: t + * c-file-style: "stroustrup" + * End: + * ex: shiftwidth=4 tabstop=8 + */ Property changes on: brlcad/trunk/src/librt/tests/nurbs_tests.cpp ___________________________________________________________________ Added: svn:mime-type + text/plain Added: svn:eol-style + native This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[55184] brlcad/trunk/src/librt From: <starseeker@us...> - 2013-04-18 20:57 Revision: 55184 http://brlcad.svn.sourceforge.net/brlcad/?rev=55184&view=rev Author: starseeker Date: 2013-04-18 20:57:28 +0000 (Thu, 18 Apr 2013) Log Message: ----------- Move dvec test into tests subdirectory Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt brlcad/trunk/src/librt/tests/CMakeLists.txt Added Paths: ----------- brlcad/trunk/src/librt/tests/test_dvec.cpp Removed Paths: ------------- brlcad/trunk/src/librt/test_dvec.cpp Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2013-04-18 20:51:30 UTC (rev 55183) +++ brlcad/trunk/src/librt/CMakeLists.txt 2013-04-18 20:57:28 UTC (rev 55184) @@ -247,7 +247,6 @@ ) set(librt_ignored_files - test_dvec.cpp columnparse.c librt_private.h namegen.c @@ -315,9 +314,6 @@ #BRLCAD_ADDEXEC(test_root3-subd test_root3-subd.cpp "librt;libwdb;libbrep;libbu" NOSTRICT NO_INSTALL) #BRLCAD_ADDEXEC(test_surfacetree test_surfacetree.cpp "librt;libwdb;libbrep;libbu" NOSTRICT NO_INSTALL) -BRLCAD_ADDEXEC(test_dvec test_dvec.cpp "librt" NOSTRICT NO_INSTALL LOCAL) -ADD_TEST(test_dvec test_dvec) - add_subdirectory(tests) # Local Variables: Deleted: brlcad/trunk/src/librt/test_dvec.cpp =================================================================== --- brlcad/trunk/src/librt/test_dvec.cpp 2013-04-18 20:51:30 UTC (rev 55183) +++ brlcad/trunk/src/librt/test_dvec.cpp 2013-04-18 20:57:28 UTC (rev 55184) @@ -1,188 +0,0 @@ -/* T E S T _ D V E C . C P P - * BRL-CAD - * - * Copyright (c) 2008-2013 United States Government as represented by - * the U.S. Army Research Laboratory. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public License - * version 2.1 as published by the Free Software Foundation. - * - * This library is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this file; see the file named COPYING for more - * information. - */ - -#include <stdio.h> -#include <stdlib.h> -#include <iostream> -#include <assert.h> -#include "vmath.h" -#include "brep.h" -#include "dvec.h" - - -const int COUNT = 1000000; - -int -main(int argc, char** argv) -{ - if (argc > 1) - printf("Usage: %s\n", argv[0]); - -#ifdef __x86_vector__ - printf("using x86 vectorization\n"); -#elif defined(__fpu_vector__) - printf("using fpu vectorization\n"); -#endif - - { - // test correctness - double _a[8] VEC_ALIGN = {0, 1, 2, 3, 4, 5, 6, 7}; - double _b[8] VEC_ALIGN = {2, 4, 6, 8, 10, 12, 14, 16}; - dvec<8> a(_a); - dvec<8> b(_b); - - dvec<8> c = a + b; - double _c[8] VEC_ALIGN = {2, 5, 8, 11, 14, 17, 20, 23}; - assert(c == dvec<8>(_c)); - - dvec<8> d = a - b; - double _d[8] VEC_ALIGN = {-2, -3, -4, -5, -6, -7, -8, -9}; - assert(d == dvec<8>(_d)); - - dvec<8> e = a * b; - double _e[8] VEC_ALIGN = {0, 4, 12, 24, 40, 60, 84, 112}; - assert(e == dvec<8>(_e)); - - dvec<8> f = a / b; - double _f[8] VEC_ALIGN = {0, 0.25, 0.333333333333, 0.375, 0.40, 0.4166666666, 0.42857142, 0.4375}; - assert(f == dvec<8>(_f)); - - dvec<8> g = a.madd(c, b); - double _g[8] VEC_ALIGN = {2, 9, 22, 41, 66, 97, 134, 177}; - assert(g == dvec<8>(_g)); - - dvec<8> h = a.madd(2.0, b); - double _h[8] VEC_ALIGN = {2, 6, 10, 14, 18, 22, 26, 30}; - assert(h == dvec<8>(_h)); - - srand(time(NULL)); - double total = 0.0; - double rval[] = { - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0 }; - - clock_t start = clock(); - for (int i = 0; i < COUNT; i++) { - double l_a[8] VEC_ALIGN = {rval[i%8], rval[i%8+1], rval[i%8+2], rval[i%8+3], - rval[i%8+4], rval[i%8+5], rval[i%8+6], rval[i%8+7]}; - double l_b[8] VEC_ALIGN = {rval[i%8+1], rval[i%8+2], rval[i%8+3], rval[i%8+4], - rval[i%8+5], rval[i%8+6], rval[i%8+7], rval[i%8+8]}; - - dvec<8> la(l_a); - dvec<8> lb(l_b); - - dvec<8> lc = la + lb; - dvec<8> ld = lc - la; - dvec<8> le = ld * lc; - dvec<8> lf = le / la; - dvec<8> lg = la.madd(rval[i%16], lf); - dvec<8> lh = lg.madd(lf, la+lb*lc-ld/le*lf); - total += lh[7]; - } - printf("dvec<8> time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); - } - -/* test correctness */ - vec2d a(100.0, -100.0); - vec2d b(200.0, -200.0); - - vec2d c = a + b; - assert(vequals(c, vec2d(300.0, -300.0))); - - vec2d d = a - b; - assert(vequals(d, vec2d(-100.0, 100.0))); - - vec2d e = a * b; - assert(vequals(e, vec2d(20000.0, 20000.0))); - - vec2d f = b / a; - assert(vequals(f, vec2d(2.0, 2.0))); - - vec2d g = a.madd(20.0, b); - assert(vequals(g, vec2d(2200.0, -2200.0))); - - vec2d h = a.madd(d, b); - assert(vequals(h, vec2d(-9800.0, -10200.0))); - -/* simple performance test */ - - srand(time(NULL)); - double total = 0.0; - double rval[] = { - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0, - rand()/10000.0 }; - - clock_t start = clock(); - for (int i = 0; i < COUNT; i++) { - vec2d la(rval[i%12], rval[i%12+2]); - vec2d lb(rval[i%12+1], rval[i%12+3]); - - vec2d lc = la + lb; - vec2d ld = lc - la; - vec2d le = ld * lc; - vec2d lf = le / la; - vec2d lg = la.madd(rval[i%12], lf); - vec2d lh = lg.madd(lg, la + lb - lc + ld - le + lf); - total += lh.x() + lh.y(); - } - printf("vec2d time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); - - /* return 'fail' if no time elapsed */ - return (total > 0) ? 0 : 1; -} - - -// Local Variables: -// tab-width: 8 -// mode: C++ -// c-basic-offset: 4 -// indent-tabs-mode: t -// c-file-style: "stroustrup" -// End: -// ex: shiftwidth=4 tabstop=8 Modified: brlcad/trunk/src/librt/tests/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/tests/CMakeLists.txt 2013-04-18 20:51:30 UTC (rev 55183) +++ brlcad/trunk/src/librt/tests/CMakeLists.txt 2013-04-18 20:57:28 UTC (rev 55184) @@ -1,6 +1,10 @@ +BRLCAD_ADDEXEC(test_dvec test_dvec.cpp "librt" NOSTRICT NO_INSTALL LOCAL) +add_test(test_dvec test_dvec) + +# NURBS testing BRLCAD_ADDEXEC(nurbs_tester nurbs_tests.cpp "librt;libbrep;libbu" NO_INSTALL LOCAL) -add_test(get_closest_point-distinct_points nurbs_tester ${CMAKE_CURRENT_SOURCE_DIR}/nurbs_surfaces.g 1) +add_test(NURBS-get_closest_point-distinct_points nurbs_tester ${CMAKE_CURRENT_SOURCE_DIR}/nurbs_surfaces.g 1) CMAKEFILES(nurbs_surfaces.g) Copied: brlcad/trunk/src/librt/tests/test_dvec.cpp (from rev 55162, brlcad/trunk/src/librt/test_dvec.cpp) =================================================================== --- brlcad/trunk/src/librt/tests/test_dvec.cpp (rev 0) +++ brlcad/trunk/src/librt/tests/test_dvec.cpp 2013-04-18 20:57:28 UTC (rev 55184) @@ -0,0 +1,188 @@ +/* T E S T _ D V E C . C P P + * BRL-CAD + * + * Copyright (c) 2008-2013 United States Government as represented by + * the U.S. Army Research Laboratory. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * version 2.1 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this file; see the file named COPYING for more + * information. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <iostream> +#include <assert.h> +#include "vmath.h" +#include "brep.h" +#include "dvec.h" + + +const int COUNT = 1000000; + +int +main(int argc, char** argv) +{ + if (argc > 1) + printf("Usage: %s\n", argv[0]); + +#ifdef __x86_vector__ + printf("using x86 vectorization\n"); +#elif defined(__fpu_vector__) + printf("using fpu vectorization\n"); +#endif + + { + // test correctness + double _a[8] VEC_ALIGN = {0, 1, 2, 3, 4, 5, 6, 7}; + double _b[8] VEC_ALIGN = {2, 4, 6, 8, 10, 12, 14, 16}; + dvec<8> a(_a); + dvec<8> b(_b); + + dvec<8> c = a + b; + double _c[8] VEC_ALIGN = {2, 5, 8, 11, 14, 17, 20, 23}; + assert(c == dvec<8>(_c)); + + dvec<8> d = a - b; + double _d[8] VEC_ALIGN = {-2, -3, -4, -5, -6, -7, -8, -9}; + assert(d == dvec<8>(_d)); + + dvec<8> e = a * b; + double _e[8] VEC_ALIGN = {0, 4, 12, 24, 40, 60, 84, 112}; + assert(e == dvec<8>(_e)); + + dvec<8> f = a / b; + double _f[8] VEC_ALIGN = {0, 0.25, 0.333333333333, 0.375, 0.40, 0.4166666666, 0.42857142, 0.4375}; + assert(f == dvec<8>(_f)); + + dvec<8> g = a.madd(c, b); + double _g[8] VEC_ALIGN = {2, 9, 22, 41, 66, 97, 134, 177}; + assert(g == dvec<8>(_g)); + + dvec<8> h = a.madd(2.0, b); + double _h[8] VEC_ALIGN = {2, 6, 10, 14, 18, 22, 26, 30}; + assert(h == dvec<8>(_h)); + + srand(time(NULL)); + double total = 0.0; + double rval[] = { + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0 }; + + clock_t start = clock(); + for (int i = 0; i < COUNT; i++) { + double l_a[8] VEC_ALIGN = {rval[i%8], rval[i%8+1], rval[i%8+2], rval[i%8+3], + rval[i%8+4], rval[i%8+5], rval[i%8+6], rval[i%8+7]}; + double l_b[8] VEC_ALIGN = {rval[i%8+1], rval[i%8+2], rval[i%8+3], rval[i%8+4], + rval[i%8+5], rval[i%8+6], rval[i%8+7], rval[i%8+8]}; + + dvec<8> la(l_a); + dvec<8> lb(l_b); + + dvec<8> lc = la + lb; + dvec<8> ld = lc - la; + dvec<8> le = ld * lc; + dvec<8> lf = le / la; + dvec<8> lg = la.madd(rval[i%16], lf); + dvec<8> lh = lg.madd(lf, la+lb*lc-ld/le*lf); + total += lh[7]; + } + printf("dvec<8> time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); + } + +/* test correctness */ + vec2d a(100.0, -100.0); + vec2d b(200.0, -200.0); + + vec2d c = a + b; + assert(vequals(c, vec2d(300.0, -300.0))); + + vec2d d = a - b; + assert(vequals(d, vec2d(-100.0, 100.0))); + + vec2d e = a * b; + assert(vequals(e, vec2d(20000.0, 20000.0))); + + vec2d f = b / a; + assert(vequals(f, vec2d(2.0, 2.0))); + + vec2d g = a.madd(20.0, b); + assert(vequals(g, vec2d(2200.0, -2200.0))); + + vec2d h = a.madd(d, b); + assert(vequals(h, vec2d(-9800.0, -10200.0))); + +/* simple performance test */ + + srand(time(NULL)); + double total = 0.0; + double rval[] = { + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0, + rand()/10000.0 }; + + clock_t start = clock(); + for (int i = 0; i < COUNT; i++) { + vec2d la(rval[i%12], rval[i%12+2]); + vec2d lb(rval[i%12+1], rval[i%12+3]); + + vec2d lc = la + lb; + vec2d ld = lc - la; + vec2d le = ld * lc; + vec2d lf = le / la; + vec2d lg = la.madd(rval[i%12], lf); + vec2d lh = lg.madd(lg, la + lb - lc + ld - le + lf); + total += lh.x() + lh.y(); + } + printf("vec2d time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); + + /* return 'fail' if no time elapsed */ + return (total > 0) ? 0 : 1; +} + + +// Local Variables: +// tab-width: 8 +// mode: C++ +// c-basic-offset: 4 +// indent-tabs-mode: t +// c-file-style: "stroustrup" +// End: +// ex: shiftwidth=4 tabstop=8 This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

[brlcad-commits] SF.net SVN: brlcad:[55710] brlcad/trunk/src/librt From: <starseeker@us...> - 2013-06-11 20:07 Revision: 55710 http://sourceforge.net/p/brlcad/code/55710 Author: starseeker Date: 2013-06-11 20:07:33 +0000 (Tue, 11 Jun 2013) Log Message: ----------- Add (commented out) file that attemps to make nicer bot wireframes using a surface patch breakout technique. Proving to be too slow for interactive use in its current form - hot spot is determing which faces share the edges with any one particular face, and even if that can somehow be made fast the pre-processing really should be done in parallel. Checkpointing so a revert point is available. Modified Paths: -------------- brlcad/trunk/src/librt/CMakeLists.txt Added Paths: ----------- brlcad/trunk/src/librt/primitives/bot/bot_wireframe.cpp Modified: brlcad/trunk/src/librt/CMakeLists.txt =================================================================== --- brlcad/trunk/src/librt/CMakeLists.txt 2013-06-11 17:20:55 UTC (rev 55709) +++ brlcad/trunk/src/librt/CMakeLists.txt 2013-06-11 20:07:33 UTC (rev 55710) @@ -257,6 +257,7 @@ prcomb.c primitives/bot/btg.h primitives/bot/g_bot_include.c + primitives/bot/bot_wireframe.cpp primitives/bot/tieprivate.h primitives/bot/tie.c primitives/bot/tie_kdtree.c Added: brlcad/trunk/src/librt/primitives/bot/bot_wireframe.cpp =================================================================== --- brlcad/trunk/src/librt/primitives/bot/bot_wireframe.cpp (rev 0) +++ brlcad/trunk/src/librt/primitives/bot/bot_wireframe.cpp 2013-06-11 20:07:33 UTC (rev 55710) @@ -0,0 +1,288 @@ +#include "common.h" + +#include <map> +#include <set> +#include <queue> +#include <list> +#include <vector> + +#include "vmath.h" +#include "raytrace.h" +#include "wdb.h" + +/************************* + * Utility functions + *************************/ + +#if 0 +// Make an edge id using the Szudzik pairing function: +long unsigned int edge_id(size_t pt_A, size_t pt_B) +{ + return (pt_A >= pt_B) ? (pt_A * pt_A + pt_A + pt_B) : (pt_B * pt_B + pt_A); +} + +// shift one of the vertex index numbers up to form a unique ID. Offset is +// log10(bot->num_vertices) + 1 +long unsigned int edge_id(size_t pt_A, size_t pt_B, int offset) +{ + return (pt_A <= pt_B) ? (pt_A * pow(10,offset) + pt_B) : (pt_B * pow(10,offset) + pt_A); +} + +void breakout(long unsigned int id, int offset, size_t *A, size_t *B) +{ + (*B) = (size_t)((long)id % (int)pow(10,offset)); + (*A) = (size_t)(id - (*B))/ (int)(pow(10, offset)); +} +#endif + +// Make an edge using consistent vertex ordering +static std::pair<size_t, size_t> +mk_edge(size_t pt_A, size_t pt_B) +{ + if (pt_A <= pt_B) { + return std::make_pair(pt_A, pt_B); + } else { + return std::make_pair(pt_B, pt_A); + } +} + + +// Calculate area of a face +static double +face_area(struct rt_bot_internal *bot, size_t face_num) +{ + point_t ptA, ptB, ptC; + double a, b, c, p; + double area; + VMOVE(ptA, &bot->vertices[bot->faces[face_num*3+0]*3]); + VMOVE(ptB, &bot->vertices[bot->faces[face_num*3+1]*3]); + VMOVE(ptC, &bot->vertices[bot->faces[face_num*3+2]*3]); + a = DIST_PT_PT(ptA, ptB); + b = DIST_PT_PT(ptB, ptC); + c = DIST_PT_PT(ptC, ptA); + p = (a + b + c)/2; + area = sqrt(p*(p-a)*(p-b)*(p-c)); + return area; +} + +// Given a BoT face, return the three other faces that share an edge with that face +static void +get_connected_faces(struct rt_bot_internal *bot, size_t face_num, std::map<size_t, std::set<size_t> > *vert_to_face, std::set<size_t> *faces) +{ + std::map<size_t, size_t> face_cnt; + size_t points[3]; + points[0] = bot->faces[face_num*3+0]*3; + points[1] = bot->faces[face_num*3+1]*3; + points[2] = bot->faces[face_num*3+2]*3; + std::set<size_t>::iterator it; + for (int i = 0; i < 3; ++i) { + for (it = (*vert_to_face)[points[i]].begin(); it != (*vert_to_face)[points[i]].end(); it++) { + face_cnt[(*it)] += 1; + } + } + std::map<size_t, size_t>::iterator mit; + for (mit = face_cnt.begin(); mit != face_cnt.end(); ++mit) { + if ((*mit).second > 1) { + faces->insert((*mit).first); + } + } +} + +/* To avoid drawing dupliate lines, build the final vlist using a set */ +static void +plot_patch_borders(std::vector<std::map<std::pair<size_t, size_t>, size_t> > *patch_edge_cnt, struct rt_bot_internal *bot, struct bu_list *vhead) +{ + std::set<std::pair<size_t, size_t> > final_edge_set; + std::set<std::pair<size_t, size_t> >::iterator fe_it; + std::map<std::pair<size_t, size_t>, size_t>::iterator e_it; + for (int i = 0; i < patch_edge_cnt->size(); i++) { + for (e_it = (*patch_edge_cnt)[i].begin(); e_it != (*patch_edge_cnt)[i].end(); e_it++) { + if ((*e_it).second == 1) { + final_edge_set.insert((*e_it).first); + } + } + } + for (fe_it = final_edge_set.begin(); fe_it != final_edge_set.end(); fe_it++) { + RT_ADD_VLIST(vhead, &(bot->vertices[(*fe_it).first]), BN_VLIST_LINE_MOVE); + RT_ADD_VLIST(vhead, &(bot->vertices[(*fe_it).second]), BN_VLIST_LINE_DRAW); + } +} + +/********************************************************** + * Code for identifying semi-flat patches in bots + * and creating wireframe edges + **********************************************************/ +extern "C" int +rt_bot_adaptive_plot(struct rt_db_internal *ip, const struct rt_view_info *info) +{ + struct rt_bot_internal *bot; + RT_CK_DB_INTERNAL(ip); + BU_CK_LIST_HEAD(info->vhead); + bot = (struct rt_bot_internal *)ip->idb_ptr; + RT_BOT_CK_MAGIC(bot); + + if (bot->num_vertices <= 0 || !bot->vertices || bot->num_faces <= 0 || !bot->faces) + return 0; + + /* Declare key containers */ + vect_t gvects[6]; + std::vector<double> face_areas; + std::vector<double> face_normals; + std::vector<std::vector<size_t> > groups; + std::vector<std::map<std::pair<size_t, size_t>, size_t> > groups_edge_face_cnt; + std::vector<std::vector<size_t> > categorization_results; + std::vector<int> face_to_plane; + std::vector<std::set<size_t> > patches; + std::map<size_t, std::set<size_t> > vert_to_face; + + /* Initialize containers */ + face_areas.resize(bot->num_faces); + face_to_plane.resize(bot->num_faces); + face_normals.resize(bot->num_faces*3); + groups.resize(6); + groups_edge_face_cnt.resize(6); + categorization_results.resize(6); + for (int i = 0; i < 6; ++i) { + categorization_results[i].resize(bot->num_faces); //categories can hold at most all faces in bot + } + patches.resize(bot->num_faces*3); // Max number of patches should be the same as the face cnt, but it isn't always + VSET(gvects[0], -1,0,0); + VSET(gvects[1], 0,-1,0); + VSET(gvects[2], 0,0,-1); + VSET(gvects[3], 1,0,0); + VSET(gvects[4], 0,1,0); + VSET(gvects[5], 0,0,1); + + // Calculate face normals dot product with bounding rpp planes + for (size_t i=0; i < bot->num_faces; ++i) { + size_t pt_A, pt_B, pt_C; + size_t result_max; + double vdot = 0.0; + double result = 0.0; + vect_t a, b, norm_dir; + // Add vert -> edge and edge -> face mappings to global map. + pt_A = bot->faces[i*3+0]*3; + pt_B = bot->faces[i*3+1]*3; + pt_C = bot->faces[i*3+2]*3; + vert_to_face[pt_A].insert(i); + vert_to_face[pt_B].insert(i); + vert_to_face[pt_C].insert(i); + // Categorize face + VSUB2(a, &bot->vertices[bot->faces[i*3+1]*3], &bot->vertices[bot->faces[i*3]*3]); + VSUB2(b, &bot->vertices[bot->faces[i*3+2]*3], &bot->vertices[bot->faces[i*3]*3]); + VCROSS(norm_dir, a, b); + VUNITIZE(norm_dir); + face_normals[i*3]=norm_dir[0]; + face_normals[i*3+1]=norm_dir[1]; + face_normals[i*3+2]=norm_dir[2]; + for (int j=0; j < 6; j++) { + vdot = VDOT(gvects[j],norm_dir); + categorization_results[j][i] = vdot; + if (vdot > result) { + result_max = j; + result = vdot; + } + } + groups[result_max].push_back(i); + face_to_plane[i]=result_max; + face_areas[i] = face_area(bot, i); + } + + // Order the groups by number of bots + std::vector<int> ordered_groups; + int group_ids[] = {0, 1, 2, 3, 4, 5}; + std::set<int> group_bin (group_ids, group_ids+6); + std::set<int>::iterator fg_it; + while (!group_bin.empty()) { + int largest_group = 0; + int max = 0; + for (fg_it = group_bin.begin(); fg_it != group_bin.end(); fg_it++) { + if (groups[(*fg_it)].size() == 0) { + group_bin.erase((*fg_it)); + } else { + if (groups[(*fg_it)].size() > max) { + max = groups[(*fg_it)].size(); + largest_group = (*fg_it); + } + } + } + if (max > 0) + ordered_groups.push_back(largest_group); + group_bin.erase(largest_group); + } + + // All faces must belong to some patch - continue until all faces are processed + std::vector<int> face_pool (bot->num_faces, 1); + std::vector<int> face_to_patch (bot->num_faces, -1); + int patch_cnt = -1; + for (int i = 0; i < ordered_groups.size(); i++) { + int largest_face = 0; + int curr_group = ordered_groups[i]; + while (largest_face != -1) { + // Start a new patch + vect_t largest_face_normal; + largest_face = -1; + patch_cnt++; + // Find largest remaining face in group + double face_size_criteria = 0.0; + for (int f_it = 0; f_it < groups[curr_group].size(); f_it++) { + if (face_pool[groups[curr_group][f_it]]) { + double fa = face_areas[groups[curr_group][f_it]]; + if (fa > face_size_criteria) { + largest_face = groups[curr_group][f_it]; + face_size_criteria = fa; + } + } + } + if (largest_face != -1) { + std::queue<int> face_queue; + face_queue.push(largest_face); + + VSET(largest_face_normal, face_normals[largest_face*3], face_normals[largest_face*3+1], face_normals[largest_face*3+2]); + face_pool[largest_face] = 0; + while (!face_queue.empty()) { + size_t pt_A, pt_B, pt_C; + int face_num = face_queue.front(); + face_queue.pop(); + patches[patch_cnt].insert(face_num); + face_to_patch[face_num] = patch_cnt; + pt_A = bot->faces[face_num*3+0]*3; + pt_B = bot->faces[face_num*3+1]*3; + pt_C = bot->faces[face_num*3+2]*3; + groups_edge_face_cnt[curr_group][mk_edge(pt_A, pt_B)] += 1; + groups_edge_face_cnt[curr_group][mk_edge(pt_B, pt_C)] += 1; + groups_edge_face_cnt[curr_group][mk_edge(pt_C, pt_A)] += 1; + + std::set<size_t> connected_faces; + std::set<size_t>::iterator cf_it; + get_connected_faces(bot, face_num, &(vert_to_face), &connected_faces); + for (cf_it = connected_faces.begin(); cf_it != connected_faces.end() ; cf_it++) { + if (face_pool[(*cf_it)]) { + double curr_face_area = face_areas[(*cf_it)]; + if (curr_face_area < (face_size_criteria*10) && curr_face_area > (face_size_criteria*0.1)) { + vect_t face_normal; + VSET(face_normal, face_normals[face_num*3], face_normals[face_num*3+1], face_normals[face_num*3+2]); + if (VDOT(largest_face_normal, face_normal) > 0.85) { + face_queue.push((*cf_it)); + face_pool[(*cf_it)] = 0; + } + } + } + } + } + } + } + } + plot_patch_borders(&(groups_edge_face_cnt), bot, info->vhead); + + return 0; +} + +// Local Variables: +// tab-width: 8 +// mode: C++ +// c-basic-offset: 4 +// indent-tabs-mode: t +// c-file-style: "stroustrup" +// End: +// ex: shiftwidth=4 tabstop=8 Property changes on: brlcad/trunk/src/librt/primitives/bot/bot_wireframe.cpp ___________________________________________________________________ Added: svn:mime-type ## -0,0 +1 ## +text/plain \ No newline at end of property Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

68 messages have been excluded from this view by a project administrator.

Next Messages