BRL-CAD
#include "common.h"
#include <stdlib.h>
#include <string.h>
#include "bio.h"
#include "vmath.h"
#include "nmg.h"
#include "raytrace.h"
#include "nurb.h"
Include dependency graph for nmg_mod.c:

Go to the source code of this file.

Macros

#define JS_UNKNOWN   0
 
#define JS_SPLIT   1
 
#define JS_JAUNT   2
 
#define JS_TOUCHING_JAUNT   3
 

Functions

void nmg_merge_regions (struct nmgregion *r1, struct nmgregion *r2, const struct bn_tol *tol)
 
void nmg_shell_coplanar_face_merge (struct shell *s, const struct bn_tol *tol, const int simplify)
 
int nmg_simplify_shell (struct shell *s)
 
void nmg_rm_redundancies (struct shell *s, const struct bn_tol *tol)
 
void nmg_sanitize_s_lv (struct shell *s, int orient)
 
void nmg_s_split_touchingloops (struct shell *s, const struct bn_tol *tol)
 
void nmg_s_join_touchingloops (struct shell *s, const struct bn_tol *tol)
 
void nmg_js (register struct shell *s1, register struct shell *s2, const struct bn_tol *tol)
 
void nmg_invert_shell (struct shell *s)
 
struct faceuse * nmg_cmface (struct shell *s, struct vertex ***verts, int n)
 
struct faceuse * nmg_cface (struct shell *s, struct vertex **verts, int n)
 
struct faceuse * nmg_add_loop_to_face (struct shell *s, struct faceuse *fu, struct vertex **verts, int n, int dir)
 
int nmg_fu_planeeqn (struct faceuse *fu, const struct bn_tol *tol)
 
void nmg_gluefaces (struct faceuse **fulist, int n, const struct bn_tol *tol)
 
int nmg_simplify_face (struct faceuse *fu)
 
void nmg_reverse_face (register struct faceuse *fu)
 
int nmg_face_fix_radial_parity (struct faceuse *fu, const struct bn_tol *tol)
 
void nmg_mv_fu_between_shells (struct shell *dest, register struct shell *src, register struct faceuse *fu)
 
void nmg_jf (register struct faceuse *dest_fu, register struct faceuse *src_fu)
 
struct faceuse * nmg_dup_face (struct faceuse *fu, struct shell *s)
 
void nmg_jl (struct loopuse *lu, struct edgeuse *eu)
 
struct vertexuse * nmg_join_2loops (struct vertexuse *vu1, struct vertexuse *vu2)
 
struct vertexuse * nmg_join_singvu_loop (struct vertexuse *vu1, struct vertexuse *vu2)
 
struct vertexuse * nmg_join_2singvu_loops (struct vertexuse *vu1, struct vertexuse *vu2)
 
struct loopuse * nmg_cut_loop (struct vertexuse *vu1, struct vertexuse *vu2)
 
struct loopuse * nmg_split_lu_at_vu (struct loopuse *lu, struct vertexuse *split_vu)
 
struct vertexuse * nmg_find_repeated_v_in_lu (struct vertexuse *vu)
 
void nmg_split_touchingloops (struct loopuse *lu, const struct bn_tol *tol)
 
int nmg_join_touchingloops (struct loopuse *lu)
 
int nmg_get_touching_jaunts (const struct loopuse *lu, struct bu_ptbl *tbl, int *need_init)
 
void nmg_kill_accordions (struct loopuse *lu)
 
int nmg_loop_split_at_touching_jaunt (struct loopuse *lu, const struct bn_tol *tol)
 
void nmg_simplify_loop (struct loopuse *lu)
 
int nmg_kill_snakes (struct loopuse *lu)
 
void nmg_mv_lu_between_shells (struct shell *dest, register struct shell *src, register struct loopuse *lu)
 
void nmg_moveltof (struct faceuse *fu, struct shell *s)
 
struct loopuse * nmg_dup_loop (struct loopuse *lu, uint32_t *parent, long int **trans_tbl)
 
void nmg_set_lu_orientation (struct loopuse *lu, int is_opposite)
 
void nmg_lu_reorient (struct loopuse *lu)
 
 if (share_geom)
 
else nmg_use_edge_g (eu2, oldeu->g.magic_p)
 
 nmg_keg (oldeumate)
 
 nmg_keg (eu1)
 
 bu_bomb ("nmg_eusplit\n")
 
 NMG_CK_LOOPUSE (lu)
 
else bu_bomb ("nmg_eusplit() bad lu->up\n")
 
 NMG_CK_SHELL (s)
 
 if (v)
 
 nmg_movevu (eu2->vu_p, eu1->vu_p->v_p)
 
 if (oldeu->g.magic_p!=oldeu->eumate_p->g.magic_p)
 

Variables

BU_LIST_DEQUEUEoldeumate
 
BU_LIST_DEQUEUEeu1
 
oldeumate l2 magic = NMG_EDGEUSE2_MAGIC
 
goto out
 
else if oldeu
 
 lu = oldeu->up.lu_p
 
if lu s = lu->up.s_p
 
 else
 
 eu2 = eu1->eumate_p
 
eu1 up magic_p = oldeu->up.magic_p
 
eu1 orientation = oldeu->orientation
 
eu1 eumate_p = oldeumate
 
eu1 radial_p = oldeumate
 
oldeumate e_p = eu1->e_p
 
oldeumate e_p eu_p = oldeumate
 

Detailed Description

Routines for modifying n-Manifold Geometry data structures.

Definition in file nmg_mod.c.

Macro Definition Documentation

#define JS_UNKNOWN   0

Definition at line 2750 of file nmg_mod.c.

Referenced by nmg_loop_split_at_touching_jaunt().

#define JS_SPLIT   1

Definition at line 2751 of file nmg_mod.c.

Referenced by nmg_loop_split_at_touching_jaunt().

#define JS_JAUNT   2

Definition at line 2752 of file nmg_mod.c.

Referenced by nmg_loop_split_at_touching_jaunt().

#define JS_TOUCHING_JAUNT   3

Definition at line 2753 of file nmg_mod.c.

Referenced by nmg_loop_split_at_touching_jaunt().

Function Documentation

void nmg_merge_regions ( struct nmgregion *  r1,
struct nmgregion *  r2,
const struct bn_tol tol 
)

Definition at line 42 of file nmg_mod.c.

References BN_CK_TOL, bu_bomb(), BU_LIST_APPEND, BU_LIST_DEQUEUE, BU_LIST_FIRST, BU_LIST_NON_EMPTY, nmg_kr(), nmg_rebound(), and s.

Referenced by rt_nmg_tess().

Here is the call graph for this function:

void nmg_shell_coplanar_face_merge ( struct shell *  s,
const struct bn_tol tol,
const int  simplify 
)

A geometric routine to find all pairs of faces in a shell that have the same plane equation (to within the given tolerance), and combine them into a single face.

Note that this may result in some of the vertices being very slightly off the plane equation, but the geometry routines need to be prepared for this in any case. If the "simplify" flag is set, pairs of loops in the face that touch will be combined into a single loop where possible.

XXX Perhaps should be recast as "nmg_shell_shared_face_merge()", leaving all the geometric calculations to the code in nmg_fuse.c ?

Definition at line 93 of file nmg_mod.c.

References bu_bomb(), bu_calloc(), bu_free(), BU_LIST_FOR, BU_LIST_NEXT, BU_LIST_NEXT_IS_HEAD, BU_LIST_NOT_HEAD, BU_LIST_PREV, bu_log(), bn_tol::dist, f1, f2, lu, NEAR_ZERO, nmg_ck_fu_verts(), rt_g::NMG_debug, nmg_jf(), nmg_shell_a(), nmg_simplify_loop(), RTG, and SMALL_FASTF.

Referenced by ged_nmg_simplify(), nmg_hollow_shell(), rt_ars_tess(), rt_ebm_tess(), rt_ehy_tess(), rt_epa_tess(), rt_hyp_tess(), and rt_vol_tess().

Here is the call graph for this function:

int nmg_simplify_shell ( struct shell *  s)

Simplify all the faces in this shell, where possible. Under some circumstances this may result in an empty shell as a result.

Returns - 0 If all was OK 1 If shell is now empty

Definition at line 209 of file nmg_mod.c.

References BU_LIST_FOR, BU_LIST_PREV, bu_log(), NMG_CK_SHELL(), rt_g::NMG_debug, nmg_kfu(), nmg_shell_is_empty(), nmg_simplify_face(), and RTG.

Referenced by ged_nmg_simplify(), nmg_hollow_shell(), and rt_ars_tess().

Here is the call graph for this function:

void nmg_rm_redundancies ( struct shell *  s,
const struct bn_tol tol 
)

Remove all redundant parts between the different "levels" of a shell. Remove wire loops that match face loops. Remove wire edges that match edges in wire loops or face loops. Remove lone vertices (stored as wire loops on a single vertex) that match vertices in a face loop, wire loop, or wire edge.

Definition at line 242 of file nmg_mod.c.

References BN_CK_TOL, BU_LIST_FIRST, BU_LIST_FIRST_MAGIC, BU_LIST_FOR, BU_LIST_NEXT, BU_LIST_NON_EMPTY, BU_LIST_NOT_HEAD, BU_LIST_PNEXT, bu_log(), lu, NMG_CK_LOOPUSE(), NMG_CK_SHELL(), nmg_classify_lu_lu(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, nmg_is_edge_in_facelist(), nmg_is_edge_in_looplist(), nmg_is_loop_in_facelist(), nmg_is_vertex_in_edgelist(), nmg_is_vertex_in_facelist(), nmg_is_vertex_in_looplist(), nmg_keu(), nmg_kfu(), nmg_klu(), NMG_VERTEXUSE_MAGIC, and RTG.

Referenced by nmg_evaluate_boolean().

Here is the call graph for this function:

void nmg_sanitize_s_lv ( struct shell *  s,
int  orient 
)

Remove those pesky little vertex-only loops of orientation "orient". Typically these will be OT_BOOLPLACE markers created in the process of doing intersections for the boolean operations.

Definition at line 564 of file nmg_mod.c.

References BU_LIST_FIRST, BU_LIST_FIRST_MAGIC, BU_LIST_IS_EMPTY, BU_LIST_NOT_HEAD, BU_LIST_PLAST, BU_LIST_PNEXT, BU_LIST_PNEXT_PNEXT, bu_log(), lu, NMG_CK_SHELL(), rt_g::NMG_debug, nmg_kfu(), nmg_klu(), NMG_VERTEXUSE_MAGIC, RTG, and VPRINT.

Here is the call graph for this function:

void nmg_s_split_touchingloops ( struct shell *  s,
const struct bn_tol tol 
)

For every loop in a shell, invoke nmg_split_touchingloops() on it.

Needed before starting classification, to separate interior (touching) loop segments into true interior loops, so each can be processed separately.

Definition at line 646 of file nmg_mod.c.

References BN_CK_TOL, BU_LIST_FOR, bu_log(), lu, NMG_CK_SHELL(), rt_g::NMG_debug, nmg_loop_split_at_touching_jaunt(), nmg_lu_reorient(), nmg_split_touchingloops(), and RTG.

Here is the call graph for this function:

void nmg_s_join_touchingloops ( struct shell *  s,
const struct bn_tol tol 
)

For every loop in a shell, invoke nmg_join_touchingloops() on it.

Definition at line 690 of file nmg_mod.c.

References BN_CK_TOL, BU_LIST_FOR, bu_log(), lu, NMG_CK_SHELL(), rt_g::NMG_debug, nmg_join_touchingloops(), nmg_lu_reorient(), and RTG.

Here is the call graph for this function:

void nmg_js ( register struct shell *  s1,
register struct shell *  s2,
const struct bn_tol tol 
)

Join two shells into one.

This is mostly an up-pointer re-labeling activity, as it is left up to the caller to ensure that there are no non-explicit intersections.

Upon return, s2 will no longer exist.

The 'tol' arg is used strictly for printing purposes.

Definition at line 740 of file nmg_mod.c.

References BN_CK_TOL, bu_bomb(), BU_LIST_FIRST, BU_LIST_NON_EMPTY, BU_LIST_NOT_HEAD, BU_LIST_PNEXT, bu_log(), lu, NMG_CK_LOOPUSE(), NMG_CK_SHELL(), rt_g::NMG_debug, nmg_find_fu_with_fg_in_s(), nmg_jf(), nmg_ks(), nmg_mv_fu_between_shells(), nmg_mv_lu_between_shells(), nmg_s_radial_harmonize(), nmg_vshell(), and RTG.

Referenced by nmg_evaluate_boolean(), nmg_extrude_cleanup(), nmg_extrude_shell(), nmg_hollow_shell(), and nmg_open_shells_connect().

Here is the call graph for this function:

void nmg_invert_shell ( struct shell *  s)

Reverse the surface normals, and invert the orientation state of all faceuses in a shell.

This turns the shell "inside out", such as might be needed for the right hand side term of a subtraction operation.

While this function is operating, the parity of faceuses radially around edgeuses is disrupted, hence this atomic interface to invert the shell.

Definition at line 890 of file nmg_mod.c.

References bu_calloc(), bu_free(), BU_LIST_FOR, bu_log(), NMG_CK_SHELL(), rt_g::NMG_debug, nmg_reverse_face(), and RTG.

Referenced by nmg_evaluate_boolean(), nmg_hollow_shell(), and rt_nmg_mirror().

Here is the call graph for this function:

struct faceuse* nmg_cmface ( struct shell *  s,
struct vertex ***  verts,
int  n 
)

Create a face with exactly one exterior loop (and no holes), given an array of pointers to struct vertex pointers. Intended to help create a "3-manifold" shell, where each edge has only two faces alongside of it. (Shades of winged edges!)

"verts" is an array of "n" pointers to pointers to (struct vertex). "s" is the parent shell for the new face.

The new face will consist of a single loop made from n edges between the n vertices. Before an edge is created between a pair of vertices, we check to see if there is already an edge with exactly one edgeuse+mate (in this shell) that runs between the two vertices. If such an edge can be found, the newly created edgeuses will just use the existing edge. This means that no special call to nmg_gluefaces() is needed later.

If a pointer in verts is a pointer to a null vertex pointer, a new vertex is created. In this way, new vertices can be created conveniently within a user's list of known vertices

verts pointers to struct vertex vertex structs

 -------            --------

0 | +–|-----—>| +–|-----------------------—> (struct vertex)


1 | +–|---------------------—>| +—|------—> (struct vertex)


2 | +–|-----—>| +–|-----------------------—> (struct vertex)


...


n | +–|---------------------—>| +—|------—> (struct vertex)


The vertices must be listed in "counter-clockwise" (CCW) order. This routine makes only topology, without reference to any geometry.

Note that this routine inserts new vertices (by edge use splitting) at the head of the loop, which reverses the order. Therefore, the caller's vertices are traversed in reverse order to counter this behavior, and to effect the proper vertex order in the final face loop.

Also note that this routine uses one level more of indirection in the verts[] array than nmg_cface().

The lu's list of eu's traverses the verts[] array in order specified by the caller. Imagine that.

Definition at line 979 of file nmg_mod.c.

References bu_bomb(), BU_LIST_FIRST, BU_LIST_PNEXT_CIRC, bu_log(), lu, NMG_CK_SHELL(), rt_g::NMG_debug, nmg_findeu(), nmg_je(), nmg_meonvu(), nmg_mf(), nmg_mlv(), and RTG.

Referenced by brep_to_nmg(), fix_halfs(), nmg_close_shell(), nmg_mc_realize_cube(), rt_arb_tess(), rt_arb_tnurb(), rt_arbn_tess(), rt_ars_tess(), rt_bot_tess(), rt_cline_tess(), rt_dsp_tess(), rt_ebm_tess(), rt_ell_tess(), rt_ell_tnurb(), rt_eto_tess(), rt_extrude_tess(), rt_nmg_adjust(), rt_part_tess(), rt_pg_tess(), rt_tgc_tess(), rt_tgc_tnurb(), rt_tor_tess(), tesselate_pipe_bend(), and tesselate_pipe_linear().

Here is the call graph for this function:

struct faceuse* nmg_cface ( struct shell *  s,
struct vertex **  verts,
int  n 
)

Create a loop within a face, given a list of vertices.

"verts" is an array of "n" pointers to (struct vertex). "s" is the parent shell for the new face. The face will consist of a single loop made from edges between the n vertices.

If verts is a null pointer (no vertex list), all vertices of the face will be new points. Otherwise, verts is a pointer to a list of vertices to use in creating the face/loop. Null entries within the list will cause a new vertex to be created for that point. Such new vertices will be inserted into the list for return to the caller.

The vertices should be listed in "counter-clockwise" (CCW) order if this is an ordinary face (loop), and in "clockwise" (CW) order if this is an interior ("hole" or "subtracted") face (loop). This routine makes only topology, without reference to any geometry.

Note that this routine inserts new vertices (by edge use splitting) at the head of the loop, which reverses the order. Therefore, the caller's vertices are traversed in reverse order to counter this behavior, and to effect the proper vertex order in the final face loop.

Definition at line 1130 of file nmg_mod.c.

References bu_bomb(), BU_LIST_FIRST, bu_log(), lu, NMG_CK_SHELL(), rt_g::NMG_debug, nmg_meonvu(), nmg_mf(), nmg_mlv(), and RTG.

Referenced by make_model_from_face(), nmg_extrude_face(), nmg_make_connect_faces(), nmg_polytonmg(), rt_dsp_tess(), rt_ehy_tess(), rt_epa_tess(), rt_hyp_tess(), rt_rhc_tess(), rt_rpc_tess(), rt_vol_tess(), tesselate_pipe_end(), and tesselate_pipe_start().

Here is the call graph for this function:

struct faceuse* nmg_add_loop_to_face ( struct shell *  s,
struct faceuse *  fu,
struct vertex **  verts,
int  n,
int  dir 
)

Create a new loop within a face, given a list of vertices. Modified version of nmg_cface().

"verts" is an array of "n" pointers to (struct vertex). "s" is the parent shell for the new face. The face will consist of a single loop made from edges between the n vertices.

If verts is a null pointer (no vertex list), all vertices of the face will be new points. Otherwise, verts is a pointer to a list of vertices to use in creating the face/loop. Null entries within the list will cause a new vertex to be created for that point. Such new vertices will be inserted into the list for return to the caller.

The vertices should be listed in "counter-clockwise" (CCW) order if this is an ordinary face (loop), and in "clockwise" (CW) order if this is an interior ("hole" or "subtracted") face (loop). This routine makes only topology, without reference to any geometry.

Note that this routine inserts new vertices (by edge use splitting) at the head of the loop, which reverses the order. Therefore, the caller's vertices are traversed in reverse order to counter this behavior, and to effect the proper vertex order in the final face loop.

Definition at line 1211 of file nmg_mod.c.

References bu_bomb(), BU_LIST_FIRST, bu_log(), lu, NMG_CK_SHELL(), rt_g::NMG_debug, nmg_meonvu(), nmg_mf(), nmg_mlv(), nmg_orientation(), and RTG.

Referenced by rt_dsp_tess(), rt_ebm_tess(), rt_extrude_tess(), rt_nmg_adjust(), and tesselate_pipe_end().

Here is the call graph for this function:

int nmg_fu_planeeqn ( struct faceuse *  fu,
const struct bn_tol tol 
)

Given a convex face that has been constructed with edges listed in counter-clockwise (CCW) order, compute the surface normal and plane equation for this face.

            D                   C
                 *-------------------*
                 |                   |
                 |   .<...........   |
    ^     N      |   .           ^   |     ^
    |      \     |   .  counter- .   |     |
    |       \    |   .   clock   .   |     |
    |C-B     \   |   .   wise    .   |     |C-B
    |         \  |   v           .   |     |
    |          \ |   ...........>.   |     |
                \|                   |
                 *-------------------*
                 A                   B
                  <-----
                    A-B

If the vertices in the loop are given in the order A B C D (e.g., counter-clockwise), then the outward pointing surface normal can be computed as:

N = (C-B) x (A-B)

This is the "right hand rule".

For reference, note that a vector which points "into" the loop can be subsequently found by taking the cross product of the surface normal and any edge vector, e.g.:

Left = N x (B-A) or Left = N x (C-B)

This routine will skip on past edges that start and end on the same vertex, in an attempt to avoid trouble. However, the loop must be convex for this routine to work. Otherwise, the surface normal may be inadvertently reversed.

Returns - 0 OK -1 failure

Definition at line 1311 of file nmg_mod.c.

References bn_3pts_collinear(), BN_CK_TOL, bn_mk_plane_3pts(), bn_pt3_pt3_equal(), BU_LIST_FIRST, BU_LIST_FIRST_MAGIC, BU_LIST_PNEXT_CIRC, bu_log(), HPRINT, lu, nmg_ck_fu_verts(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, nmg_face_g(), RTG, SMALL_FASTF, and V3ARGS.

Referenced by brep_to_nmg(), nmg_mc_realize_cube(), rt_arbn_tess(), rt_dsp_tess(), rt_ebm_tess(), rt_ehy_tess(), rt_ell_tess(), rt_epa_tess(), rt_eto_tess(), rt_hyp_tess(), rt_part_tess(), rt_rhc_tess(), rt_rpc_tess(), rt_tor_tess(), and rt_vol_tess().

Here is the call graph for this function:

void nmg_gluefaces ( struct faceuse **  fulist,
int  n,
const struct bn_tol tol 
)

given a shell containing "n" faces whose outward oriented faceuses are enumerated in "fulist", glue the edges of the faces together Most especially useful after using nmg_cface() several times to make faces which share vertex structures.

Definition at line 1408 of file nmg_mod.c.

References BU_LIST_FIRST_MAGIC, BU_LIST_FOR, bu_log(), bu_ptbl_free(), bu_ptbl_init(), bu_ptbl_ins(), lu, rt_g::NMG_debug, nmg_edge_fuse(), NMG_EDGEUSE_MAGIC, and RTG.

Referenced by nmg_decompose_shell(), nmg_dup_shell(), nmg_extrude_face(), nmg_open_shells_connect(), rt_ehy_tess(), rt_epa_tess(), rt_hyp_tess(), rt_rhc_tess(), rt_rpc_tess(), and rt_tgc_tess().

Here is the call graph for this function:

int nmg_simplify_face ( struct faceuse *  fu)

combine adjacent loops within a face which serve no apparent purpose by remaining separate and distinct. Kill "wire-snakes" in face.

Returns - 0 If all was OK 1 If faceuse is now empty

Definition at line 1446 of file nmg_mod.c.

References BU_LIST_FOR, BU_LIST_IS_EMPTY, BU_LIST_PREV, bu_log(), lu, rt_g::NMG_debug, nmg_kill_snakes(), nmg_klu(), nmg_simplify_loop(), and RTG.

Referenced by nmg_simplify_shell().

Here is the call graph for this function:

void nmg_reverse_face ( register struct faceuse *  fu)

This routine reverses the direction of the Normal vector which defines the plane of the face.

The OT_SAME faceuse becomes the OT_OPPOSITE faceuse, and vice versa. This preserves the convention that OT_SAME loopuses in the OT_SAME faceuse are counter-clockwise rotating about the surface normal.

      Before                        After

N OT_SAME OT_OPPOSITE \ .<------—. .<------—. \ |fu ^ |fu ^ \ | .---— | ->. | .---— | ->. | ^fumate | | | ^fumate | |

V V \

.------—>. | .------—>. | \ | V | V \ .<-------—. .<-------—. \ OT_OPPOSITE OT_SAME \ N

Also note that this reverses the same:opposite:opposite:same parity radially around each edge. This can create parity errors until all faces of this shell have been processed.

Applications programmers should use nmg_invert_shell(), which does not have this problem.

THIS ROUTINE IS FOR INTERNAL USE ONLY.

Definition at line 1511 of file nmg_mod.c.

References bu_bomb(), bu_log(), rt_g::NMG_debug, and RTG.

Referenced by nmg_extrude_face(), nmg_invert_shell(), nmg_propagate_normals(), nmg_reverse_face_and_radials(), and rt_extrude_tess().

Here is the call graph for this function:

int nmg_face_fix_radial_parity ( struct faceuse *  fu,
const struct bn_tol tol 
)

XXX Called in nmg_misc.c / nmg_reverse_face_and_radials() Around an edge, consider all the edgeuses that belong to a single shell. The faceuses pertaining to those edgeuses must maintain the appropriate parity with their radial faceuses, so that OT_SAME is always radial to OT_SAME, and OT_OPPOSITE is always radial to OT_OPPOSITE.

If a radial edgeuse is encountered that belongs to this face, then it might not have been processed by this routine yet, and is ignored for the purposes of checking parity.

When moving faces between shells, sometimes this parity relationship needs to be fixed, which can be easily accomplished by exchanging the incorrect edgeuse with its mate in the radial edge linkages.

XXX Note that this routine will not work right in the presence of XXX dangling faces.

Note that this routine can't be used incrementally, because after an odd number (like one) of faceuses have been "fixed", there is an inherent parity error, which will cause wrong decisions to be made. Therefore, all faces have to be moved from one shell to another before the radial parity can be "fixed". Even then, this isn't going to work right unless we are given a list of all the "suspect" faceuses, so the initial parity value can be properly established.

XXXX I am of the opinion this routine is neither useful nor correct XXXX in its present form, except for limited special cases.

The 'tol' arg is used strictly for printing purposes.

Returns - count of number of edges fixed.

Definition at line 1593 of file nmg_mod.c.

References BN_CK_TOL, BU_LIST_FIRST_MAGIC, BU_LIST_FOR, bu_log(), lu, NMG_CK_LOOPUSE(), NMG_CK_SHELL(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, nmg_find_fu_of_eu(), nmg_find_s_of_eu(), RTG, and s.

Here is the call graph for this function:

void nmg_mv_fu_between_shells ( struct shell *  dest,
register struct shell *  src,
register struct faceuse *  fu 
)

Move faceuse from 'src' shell to 'dest' shell.

Definition at line 1702 of file nmg_mod.c.

References bu_bomb(), BU_LIST_APPEND, BU_LIST_DEQUEUE, BU_LIST_IS_EMPTY, bu_log(), rt_g::NMG_debug, and RTG.

Referenced by nmg_decompose_shell(), nmg_isect_shell_self(), and nmg_js().

Here is the call graph for this function:

void nmg_jf ( register struct faceuse *  dest_fu,
register struct faceuse *  src_fu 
)

Join two faces together by moving everything from the source faceuse and mate into the destination faceuse and mate, taking into account face orientations. The source face is destroyed by this operation.

Definition at line 1791 of file nmg_mod.c.

References bu_bomb(), bu_log(), rt_g::NMG_debug, nmg_kfu(), and RTG.

Referenced by nmg_js(), and nmg_shell_coplanar_face_merge().

Here is the call graph for this function:

struct faceuse* nmg_dup_face ( struct faceuse *  fu,
struct shell *  s 
)

Construct a duplicate of a face into the shell 's'. The vertex geometry is copied from the source face into topologically distinct (new) vertex and vertex_g structs. They will start out being geometrically coincident, but it is anticipated that the caller will modify the geometry, e.g. as in an extrude operation.

It is the caller's responsibility to re-bound the new face after making any modifications.

Definition at line 1827 of file nmg_mod.c.

References bu_calloc(), bu_free(), BU_LIST_FOR, bu_log(), lu, NMG_CK_SHELL(), rt_g::NMG_debug, nmg_dup_loop(), nmg_face_g(), NMG_FACE_G_PLANE_MAGIC, nmg_face_g_snurb(), NMG_FACE_G_SNURB_MAGIC, nmg_find_model(), nmg_mf(), nmg_orientation(), and RTG.

Referenced by ged_fracture(), nmg_extrude_face(), nmg_to_poly(), and stash_shell().

Here is the call graph for this function:

void nmg_jl ( struct loopuse *  lu,
struct edgeuse *  eu 
)

Join two loops together which share a common edge, such that both occurrences of the common edge are deleted. This routine always leaves "lu" intact, and kills the loop radial to "eu" (after stealing all its edges).

Either both loops must be of the same orientation, or then first loop must be OT_SAME, and the second loop must be OT_OPPOSITE. Joining OT_SAME & OT_OPPOSITE always gives an OT_SAME result. Above statement is not true!!!! I have added nmg_lu_reorient() -JRA Since "lu" must survive, it must be the OT_SAME one.

Definition at line 1945 of file nmg_mod.c.

References bu_bomb(), BU_LIST_APPEND, BU_LIST_DEQUEUE, BU_LIST_INSERT, BU_LIST_PNEXT_CIRC, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, nmg_keu(), nmg_klu(), NMG_LOOPUSE_MAGIC, nmg_lu_reorient(), nmg_orientation(), and RTG.

Referenced by nmg_simplify_loop().

Here is the call graph for this function:

struct vertexuse* nmg_join_2loops ( struct vertexuse *  vu1,
struct vertexuse *  vu2 
)

Intended to join an interior and exterior loop together, by building a bridge between the two indicated vertices.

This routine can be used to join two exterior loops which do not overlap, and it can also be used to join an exterior loop with a loop of opposite orientation that lies entirely within it. This restriction is important, but not checked for.

If the two vertexuses reference distinct vertices, then two new edges are built to bridge the loops together. If the two vertexuses share the same vertex, then it is even easier.

Returns the replacement for vu2.

Definition at line 2043 of file nmg_mod.c.

References bu_bomb(), BU_LIST_APPEND, BU_LIST_DEQUEUE, BU_LIST_INSERT, BU_LIST_NON_EMPTY, BU_LIST_PNEXT_CIRC, BU_LIST_PPREV_CIRC, bu_log(), eu1, eu2, NMG_CK_LOOPUSE(), rt_g::NMG_debug, nmg_je(), nmg_klu(), nmg_lu_reorient(), and RTG.

Referenced by nmg_face_state_transition(), nmg_fcut_face(), and nmg_join_touchingloops().

Here is the call graph for this function:

struct vertexuse* nmg_join_singvu_loop ( struct vertexuse *  vu1,
struct vertexuse *  vu2 
)

vu1 is in a regular loop, vu2 is in a loop of a single vertex A jaunt is taken from vu1 to vu2 and back to vu1, and the old loop at vu2 is destroyed.

Return is the new vu that replaces vu2.

Definition at line 2137 of file nmg_mod.c.

References bu_bomb(), BU_LIST_PPREV_CIRC, bu_log(), eu1, NMG_CK_LOOPUSE(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, nmg_je(), nmg_klu(), NMG_LOOPUSE_MAGIC, and RTG.

Referenced by nmg_face_state_transition(), and nmg_fcut_face().

Here is the call graph for this function:

struct vertexuse* nmg_join_2singvu_loops ( struct vertexuse *  vu1,
struct vertexuse *  vu2 
)

Both vertices are part of single vertex loops. Converts loop on vu1 into a real loop that connects them together, with a single edge (two edgeuses). Loop on vu2 is killed.

Returns replacement vu for vu2. Does not change the orientation.

Definition at line 2186 of file nmg_mod.c.

References bu_bomb(), BU_LIST_PPREV_CIRC, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, nmg_je(), nmg_klu(), NMG_LOOPUSE_MAGIC, nmg_meonvu(), and RTG.

Referenced by nmg_face_state_transition(), and nmg_fcut_face().

Here is the call graph for this function:

struct loopuse* nmg_cut_loop ( struct vertexuse *  vu1,
struct vertexuse *  vu2 
)

Divide a loop of edges between two vertexuses.

Make a new loop between the two vertexes, and split it and the loop of the vertexuses at the same time.

    BEFORE                                  AFTER


Va    eu1  vu1              Vb             Va   eu1  vu1             Vb
 * <---------* <---------*          * <--------*  * <--------*
 |                                  |             |
 |                  ^               |          ^  |          ^
 |   Original       |               | Original |  |    New   |
 |     Loopuse      |               | Loopuse  |  |  Loopuse |
 V                  |               V          |  V /        |
                    |                          |   /         |
 *----------> *--------> *          *--------> *  *--------> *
Vd       vu2 eu2    Vc             Vd             vu2  eu2   Vc

Returns the new loopuse pointer. The new loopuse will contain "vu2" and the edgeuse associated with "vu2" as the FIRST edgeuse on the list of edgeuses. The edgeuse for the new edge (connecting the vertices indicated by vu1 and vu2) will be the LAST edgeuse on the new loopuse's list of edgeuses.

It is the caller's responsibility to re-bound the loops.

Both old and new loopuse will have orientation OT_UNSPEC. It is the callers responsibility to determine what the orientations should be. This can be conveniently done with nmg_lu_reorient().

Here is a simple example of how the new loopuse might have a different orientation than the original one:

    F<----------------E
    |                 ^
    |                 |
    |      C--------->D
    |      ^          .
    |      |          .
    |      |          .
    |      B<---------A
    |                 ^
    v                 |
    G---------------->H

When nmg_cut_loop(A, D) is called, the new loop ABCD is clockwise, even though the original loop was counter-clockwise. There is no way to determine this without referring to the face normal and vertex geometry, which being a topology routine this routine shouldn't do.

Returns - NULL on Error lu is loopuse of new loop, on success.

Definition at line 2283 of file nmg_mod.c.

References bu_bomb(), bu_calloc(), bu_free(), BU_LIST_APPEND, BU_LIST_DEQUEUE, BU_LIST_FIRST, BU_LIST_INSERT, BU_LIST_PNEXT_CIRC, bu_log(), eu1, eu2, lu, NMG_CK_LOOPUSE(), nmg_ck_lueu(), rt_g::NMG_debug, nmg_find_s_of_eu(), nmg_je(), nmg_kvu(), nmg_me(), nmg_mlv(), nmg_pl_fu(), nmg_split_lu_at_vu(), out, and RTG.

Referenced by fix_halfs(), nmg_face_state_transition(), nmg_fcut_face(), and nmg_make_faces_at_vert().

Here is the call graph for this function:

struct loopuse* nmg_split_lu_at_vu ( struct loopuse *  lu,
struct vertexuse *  split_vu 
)

In a loop which has at least two distinct uses of a vertex, split off the edges from "split_vu" to the second occurrence of the vertex into a new loop. It is the caller's responsibility to re-bound the loops.

The old and new loopuses will have orientation OT_UNSPEC. It is the callers responsibility to determine what their orientations should be. This can be conveniently done with nmg_lu_reorient().

Here is an example:

               E<__________B <___________A
               |           ^\            ^
               |          /  \           |
               |         /    \          |
               |        /      v         |
               |       D<_______C        |
               v                         |
               F________________________>G

When nmg_split_lu_at_vu(lu, B) is called, the old loopuse continues to be counter clockwise and OT_SAME, but the new loopuse BCD is now clockwise. It needs to be marked OT_OPPOSITE. Without referring to the geometry, this can't be determined.

Intended primarily for use by nmg_split_touchingloops().

Returns - NULL on Error lu is loopuse of new loop, on success.

Definition at line 2457 of file nmg_mod.c.

References bu_bomb(), BU_LIST_APPEND, BU_LIST_DEQUEUE, BU_LIST_FIRST, BU_LIST_INSERT, BU_LIST_PNEXT_CIRC, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, nmg_kvu(), nmg_mlv(), out, and RTG.

Referenced by nmg_cut_loop(), nmg_cut_lu_into_coplanar_and_non(), nmg_extrude_cleanup(), nmg_face_state_transition(), nmg_kill_cracks(), nmg_loop_split_at_touching_jaunt(), and nmg_split_touchingloops().

Here is the call graph for this function:

struct vertexuse* nmg_find_repeated_v_in_lu ( struct vertexuse *  vu)

Given a vertexuse of an edgeuse in a loopuse, see if the vertex is used by at least one other vertexuse in that same loopuse.

Returns - vu if this vertex appears elsewhere in the loopuse. NULL if this is the only occurrence of this vertex in the loopuse.

XXX move to nmg_info.c

Definition at line 2533 of file nmg_mod.c.

References BU_LIST_FOR, lu, NMG_CK_LOOPUSE(), NMG_EDGEUSE_MAGIC, NMG_LOOPUSE_MAGIC, and OSL::Strings::v.

Referenced by nmg_get_touching_jaunts(), and nmg_split_touchingloops().

Here is the call graph for this function:

void nmg_split_touchingloops ( struct loopuse *  lu,
const struct bn_tol tol 
)

Search through all the vertices in a loop. Whenever there are two distinct uses of one vertex in the loop, split off all the edges between them into a new loop.

Note that the call to nmg_split_lu_at_vu() will cause the split loopuses to be marked OT_UNSPEC.

Definition at line 2585 of file nmg_mod.c.

References BN_CK_TOL, BU_LIST_FIRST_MAGIC, BU_LIST_FOR, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, nmg_eu_is_part_of_crack(), nmg_find_lu_of_vu(), nmg_find_repeated_v_in_lu(), nmg_loop_g(), nmg_split_lu_at_vu(), RTG, and top().

Referenced by nmg_s_split_touchingloops(), nmg_triangulate_fu(), and rt_dsp_tess().

Here is the call graph for this function:

int nmg_join_touchingloops ( struct loopuse *  lu)

Search through all the vertices in a loopuse that belongs to a faceuse. Whenever another loopuse in the same faceuse refers to one of this loop's vertices, the two loops touch at (at least) that vertex. Join them together.

Return - count of loops joined (eliminated)

Definition at line 2678 of file nmg_mod.c.

References BU_LIST_FIRST_MAGIC, BU_LIST_FOR, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, NMG_FACEUSE_MAGIC, nmg_join_2loops(), NMG_LOOPUSE_MAGIC, RTG, top(), and OSL::Strings::v.

Referenced by nmg_s_join_touchingloops(), and rt_dsp_tess().

Here is the call graph for this function:

int nmg_get_touching_jaunts ( const struct loopuse *  lu,
struct bu_ptbl tbl,
int *  need_init 
)

Create a table of EU's. Each EU will be the first EU in a touching jaunt (edgeuses from vert A->B->A) where vertex B appears elsewhere in the loopuse lu.

returns: count of touching jaunts found

The passed pointer to an bu_ptbl structure may not be initialized. If no touching jaunts are found, it will still not be initialized upon return (to avoid bu_malloc/bu_free pairs for loops with no touching jaunts. The flag (need_init) lets this routine know whether the ptbl structure has been initialized

Definition at line 2771 of file nmg_mod.c.

References BU_LIST_FIRST_MAGIC, BU_LIST_FOR, BU_LIST_PNEXT_CIRC, bu_ptbl_init(), bu_ptbl_ins(), eu2, NMG_CK_LOOPUSE(), NMG_EDGEUSE_MAGIC, and nmg_find_repeated_v_in_lu().

Referenced by nmg_loop_split_at_touching_jaunt().

Here is the call graph for this function:

void nmg_kill_accordions ( struct loopuse *  lu)

Definition at line 2934 of file nmg_mod.c.

References BU_LIST_FIRST, BU_LIST_FIRST_MAGIC, BU_LIST_FOR, BU_LIST_IS_EMPTY, BU_LIST_NOT_HEAD, BU_LIST_PNEXT, BU_LIST_PNEXT_CIRC, BU_LIST_PPREV_CIRC, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, nmg_keu(), and RTG.

Referenced by nmg_loop_split_at_touching_jaunt().

Here is the call graph for this function:

int nmg_loop_split_at_touching_jaunt ( struct loopuse *  lu,
const struct bn_tol tol 
)

If a loop makes a "jaunt" (edgeuses from verts A->B->A), where the tip of the jaunt touches the same loop at a different vertexuse, cut the loop into two.

This produces a much more reasonable loop split than nmg_split_touchingloops(), which tends to peel off 2-edge "cracks" as it unravels the loop.

Note that any loops so split will be marked OT_UNSPEC.

Definition at line 2997 of file nmg_mod.c.

References BN_CK_TOL, bu_bomb(), bu_calloc(), BU_CK_PTBL, bu_free(), BU_LIST_PNEXT_CIRC, bu_log(), BU_PTBL_END, bu_ptbl_free(), BU_PTBL_GET, bu_ptbl_reset(), eu2, JS_JAUNT, JS_SPLIT, JS_TOUCHING_JAUNT, JS_UNKNOWN, NMG_CK_LOOPUSE(), rt_g::NMG_debug, nmg_find_model(), nmg_get_touching_jaunts(), nmg_kill_accordions(), nmg_loop_g(), nmg_pr_lu_briefly(), nmg_split_lu_at_vu(), nmg_stash_model_to_file(), RTG, and top().

Referenced by nmg_s_split_touchingloops(), and nmg_triangulate_fu().

Here is the call graph for this function:

void nmg_simplify_loop ( struct loopuse *  lu)

combine adjacent loops within the same parent that touch along a common edge into a single loop, with the edge eliminated.

Definition at line 3230 of file nmg_mod.c.

References BU_LIST_FIRST, BU_LIST_FIRST_MAGIC, BU_LIST_NOT_HEAD, BU_LIST_PLAST, BU_LIST_PNEXT, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, NMG_FACEUSE_MAGIC, nmg_jl(), NMG_LOOPUSE_MAGIC, nmg_pl_2fu(), and RTG.

Referenced by nmg_shell_coplanar_face_merge(), and nmg_simplify_face().

Here is the call graph for this function:

int nmg_kill_snakes ( struct loopuse *  lu)

Removes "snake" or "disconnected crack" edges from loopuse.

Returns - 0 If all went well 1 If the loopuse is now empty and needs to be killed.

Definition at line 3302 of file nmg_mod.c.

References BU_LIST_FIRST, BU_LIST_FIRST_MAGIC, BU_LIST_IS_EMPTY, BU_LIST_NOT_HEAD, BU_LIST_PNEXT, BU_LIST_PNEXT_CIRC, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, NMG_EDGEUSE_MAGIC, NMG_FACEUSE_MAGIC, nmg_keu(), NMG_LOOPUSE_MAGIC, nmg_pl_2fu(), RTG, and OSL::Strings::v.

Referenced by nmg_simplify_face(), and rt_vol_tess().

Here is the call graph for this function:

void nmg_mv_lu_between_shells ( struct shell *  dest,
register struct shell *  src,
register struct loopuse *  lu 
)

Move a wire-loopuse from one shell to another. Note that this routine can not be used on loops in faces.

Definition at line 3373 of file nmg_mod.c.

References bu_bomb(), BU_LIST_APPEND, BU_LIST_DEQUEUE, BU_LIST_IS_EMPTY, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, and RTG.

Referenced by nmg_js().

Here is the call graph for this function:

void nmg_moveltof ( struct faceuse *  fu,
struct shell *  s 
)

move first pair of shell wire loopuses out to become a genuine loop in an existing face.

XXX This routine is not used anywhere, and may not work.

Definition at line 3424 of file nmg_mod.c.

References BU_LIST_APPEND, BU_LIST_DEQUEUE, BU_LIST_FIRST, bu_log(), NMG_CK_LOOPUSE(), NMG_CK_SHELL(), rt_g::NMG_debug, and RTG.

Here is the call graph for this function:

struct loopuse* nmg_dup_loop ( struct loopuse *  lu,
uint32_t *  parent,
long int **  trans_tbl 
)

A support routine for nmg_dup_face()

trans_tbl may be NULL.

Definition at line 3459 of file nmg_mod.c.

References bu_bomb(), BU_LIST_FIRST, BU_LIST_FIRST_MAGIC, BU_LIST_FOR, BU_LIST_LAST, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, nmg_edge_g(), nmg_meonvu(), nmg_mlv(), nmg_orientation(), nmg_vertex_gv(), NMG_VERTEXUSE_MAGIC, and RTG.

Referenced by nmg_dup_face(), and nmg_dup_shell().

Here is the call graph for this function:

void nmg_set_lu_orientation ( struct loopuse *  lu,
int  is_opposite 
)

Set this loopuse and mate's orientation to be SAME or OPPOSITE from the orientation of the faceuse they each reside in.

Definition at line 3620 of file nmg_mod.c.

References bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, and RTG.

Referenced by cut_unimonotone(), nmg_face_state_transition(), and nmg_triangulate_fu().

Here is the call graph for this function:

void nmg_lu_reorient ( struct loopuse *  lu)

Based upon a geometric calculation, reorient a loop and its mate, if the stored orientation differs from the geometric one.

Note that the loopuse and its mate have the same orientation; it's the faceuses that are normalward and anti-normalward. The loopuses either both agree with their faceuse, or both differ.

Definition at line 3649 of file nmg_mod.c.

References bu_bomb(), BU_LIST_FIRST_MAGIC, bu_log(), NMG_CK_LOOPUSE(), rt_g::NMG_debug, nmg_loop_plane_newell(), nmg_orientation(), NMG_VERTEXUSE_MAGIC, RTG, and SMALL_FASTF.

Referenced by fix_halfs(), nmg_cut_lu_into_coplanar_and_non(), nmg_face_state_transition(), nmg_fcut_face(), nmg_jl(), nmg_join_2loops(), nmg_kill_cracks(), nmg_s_join_touchingloops(), nmg_s_split_touchingloops(), nmg_triangulate_fu(), and rt_dsp_tess().

Here is the call graph for this function:

if ( share_geom  )

Split an edgeuse by inserting a vertex into middle of the edgeuse.

Make a new edge, and a vertex. If v is non-null it is taken as a pointer to an existing vertex to use as the start of the new edge. If v is null, then a new vertex is created for the beginning of the new edge.

In either case, the new edge will exist as the "next" edgeuse after the edgeuse passed as a parameter.

Upon return, the new edgeuses (eu1 and mate) will not refer to any geometry, unless argument "share_geom" was non-zero.

Explicit return - edgeuse of new edge "eu1", starting at V and going to B.

List on entry -

oldeu .----------—> / A =============== B (edge) / <----------—. oldeumate

List on return -

              oldeu(cw) eu1
             .------->   .----->
            /           /
    (edge) A ========= V ~~~~~~~ B (new edge)
                      /         /
             <-------.   <-----.
                mate      mate

*/ struct edgeuse * nmg_eusplit(struct vertex *v, struct edgeuse *oldeu, int share_geom) { struct edgeuse *eu1, *eu2, *oldeumate; struct shell *s = NULL; struct loopuse *lu;

NMG_CK_EDGEUSE(oldeu); if (v) { NMG_CK_VERTEX(v); } oldeumate = oldeu->eumate_p; NMG_CK_EDGEUSE(oldeumate);

/* if this edge has uses other than this edge and its mate, we must separate these two edgeuses from the existing edge, and create a new edge for them. Then we can insert a new vertex in this new edge without fear of damaging some other object. */ if (oldeu->radial_p != oldeumate) nmg_unglueedge(oldeu);

if (*oldeu->up.magic_p == NMG_SHELL_MAGIC) { s = oldeu->up.s_p; NMG_CK_SHELL(s);

/* Make an edge from the new vertex ("V") to vertex at other end of the edge given ("B"). The new vertex "V" may be NULL, which will cause the shell's lone vertex to be used, or a new one obtained. New edges will be placed at head of shell's edge list. */ eu1 = nmg_me(v, oldeumate->vu_p->v_p, s); eu2 = eu1->eumate_p;

/* The situation is now:

 eu1                            oldeu

.--------—> .----------—> / / *V ~~~~~~~~~~~~~ B (new edge) A =============== B (edge) / / <--------—. <----------—. eu2 oldeumate */

/* Make oldeumate start at "V", not "B" */ nmg_movevu(oldeumate->vu_p, eu1->vu_p->v_p);

/* Enforce rigid ordering in shell's edge list: oldeu, oldeumate, eu1, eu2. This is to keep edges & mates "close to each other". */ if (BU_LIST_PNEXT(edgeuse, oldeu) != oldeumate) { BU_LIST_DEQUEUE(&oldeumate->l); BU_LIST_APPEND(&oldeu->l, &oldeumate->l); } BU_LIST_DEQUEUE(&eu1->l); BU_LIST_DEQUEUE(&eu2->l); BU_LIST_APPEND(&oldeumate->l, &eu1->l); BU_LIST_APPEND(&eu1->l, &eu2->l);

/* oldeu(cw) eu1 .----—> .--—> / / (edge) A ========= V ~~~~~~~ B (new edge) / / <----—. <--—. oldeumate eu2

Definition at line 3829 of file nmg_mod.c.

References nmg_use_edge_g().

Referenced by _ged_append_pipept_common(), _ged_print_node(), bn_table_lin_interp(), brep_conversion_comb(), brick_render(), bu_hist_range(), build_comb(), bwtxt_render(), cloud_render(), combmem_set_empty(), db5_realloc(), db5_scan(), db_comb_mvall(), edit_arg_duplicate_in_place(), edit_arg_expand_meta(), f_nnodes(), fb_seek(), ged_bo(), ged_bot_edge_split(), ged_bot_face_split(), ged_brep(), ged_delete_metaballpt(), ged_delete_pipept(), ged_eac(), ged_export_polygon(), ged_get_bot_edges(), ged_get_comb(), ged_import_polygon(), ged_move_botpt(), ged_move_metaballpt(), ged_move_pipept(), ged_rcodes(), ged_trace(), ged_which_shader(), ged_xpush(), get_obj_data(), hit(), icv_writeline(), isect_ray_lseg(), linear_pipe_shot(), mk_bot_w_normals(), mlib_free(), nmg_clone_model(), nmg_disconnect_shells(), nmg_purge_unwanted_intersection_points(), nmg_triangulate_rm_degen_loopuse(), path_validate_recurse(), ptbl_vsort(), pull_comb(), qt_handle_event(), ray_hit_vertex(), rt_advance_to_next_cell(), rt_arb_class(), rt_arb_free(), rt_arb_import4(), rt_arb_print(), rt_arb_shot(), rt_arb_uv(), rt_arbn_adjust(), rt_arbn_centroid(), rt_arbn_import4(), rt_arbn_import5(), rt_arbn_uv(), rt_ars_class(), rt_ars_curve(), rt_ars_free(), rt_ars_import4(), rt_ars_norm(), rt_ars_print(), rt_ars_uv(), rt_bot_export5(), rt_bot_free(), rt_bot_import4(), rt_bot_makesegs(), rt_bot_norm(), rt_bot_piece_shot(), rt_bot_shot(), rt_brep_adjust(), rt_brep_curve(), rt_brep_free(), rt_brep_norm(), rt_brep_print(), rt_brep_process_selection(), rt_brep_shot(), rt_brep_uv(), rt_cline_export4(), rt_cline_free(), rt_cline_import4(), rt_cline_shot(), rt_comb_export5(), rt_comb_ifree(), rt_comb_import4(), rt_constraint_ifree(), rt_dsp_describe(), rt_dsp_free(), rt_dsp_get(), rt_dsp_import4(), rt_dsp_plot(), rt_ebm_curve(), rt_ebm_dda(), rt_ebm_import4(), rt_ehy_export4(), rt_ehy_import4(), rt_ehy_plot(), rt_ehy_prep(), rt_ehy_tess(), rt_ehy_uv(), rt_ell_import4(), rt_epa_adaptive_plot(), rt_epa_export4(), rt_epa_import4(), rt_epa_plot(), rt_epa_prep(), rt_epa_tess(), rt_epa_uv(), rt_eto_adaptive_plot(), rt_eto_export4(), rt_eto_export5(), rt_eto_import4(), rt_eto_plot(), rt_eto_prep(), rt_eto_uv(), rt_extrude_bbox(), rt_extrude_free(), rt_extrude_import4(), rt_extrude_prep(), rt_grp_import4(), rt_grp_print(), rt_hf_curve(), rt_hf_free(), rt_hf_import4(), rt_hf_shot(), rt_hf_uv(), rt_hlf_curve(), rt_hlf_import4(), rt_hlf_print(), rt_hlf_uv(), rt_hyp_uv(), rt_joint_print(), rt_joint_process_selection(), rt_memfree(), rt_metaball_curve(), rt_metaball_uv(), rt_nmg_import4(), rt_nmg_import4_internal(), rt_nmg_shot(), rt_nurb_curve(), rt_nurb_free(), rt_nurb_import4(), rt_nurb_print(), rt_nurb_shot(), rt_part_import4(), rt_part_shot(), rt_pg_import4(), rt_pg_print(), rt_pipe_import4(), rt_pipe_print(), rt_pr_cut_info(), rt_rec_uv(), rt_revolve_uv(), rt_rhc_adaptive_plot(), rt_rhc_export4(), rt_rhc_export5(), rt_rhc_import4(), rt_rhc_plot(), rt_rhc_prep(), rt_rhc_tess(), rt_rhc_uv(), rt_rpc_adaptive_plot(), rt_rpc_import4(), rt_rpc_plot(), rt_rpc_prep(), rt_rpc_tess(), rt_rpc_uv(), rt_sketch_describe(), rt_sketch_import4(), rt_sketch_import5(), rt_submodel_import4(), rt_submodel_wireframe_leaf(), rt_superell_import4(), rt_tgc_curve(), rt_tgc_import4(), rt_tgc_uv(), rt_tor_export4(), rt_tor_import4(), rt_tor_uv(), rt_vol_free(), rt_vol_import4(), rt_vol_shot(), rt_xxx_curve(), rt_xxx_free(), rt_xxx_norm(), rt_xxx_print(), rt_xxx_shot(), rt_xxx_uv(), scloud_render(), tie_kdtree_prep(), to_mouse_move_botpt(), tthrm_render(), tthrm_setup(), and XGLUE().

Here is the call graph for this function:

else nmg_use_edge_g ( eu2  ,
oldeu->g.  magic_p 
)

Referenced by if().

nmg_keg ( oldeumate  )
nmg_keg ( eu1  )
NMG_CK_LOOPUSE ( lu  )

Referenced by _ged_get_solid_keypoint(), cut_unimonotone(), insert_above(), insert_node(), isect_ray_loopuse(), nmg_2_vrml(), nmg_2lu_identical(), nmg_bad_face_normals(), nmg_break_crossed_loops(), nmg_break_long_edges(), nmg_build_loopuse_tree(), nmg_check_closed_shell(), nmg_check_radial(), nmg_ck_closed_surf(), nmg_ck_face_worthless_edges(), nmg_ck_fu(), nmg_ck_fu_verts(), nmg_ck_l(), nmg_ck_lu(), nmg_ck_lu_orientation(), nmg_class_lu_fu(), nmg_class_pt_euvu(), nmg_class_pt_fu_except(), nmg_class_pt_lu_except(), nmg_classify_lu_lu(), nmg_classify_lu_lu_new(), nmg_classify_pt_loop(), nmg_classify_pt_loop_new(), nmg_close_shell(), nmg_crackshells(), nmg_cut_loop(), nmg_cut_lu_into_coplanar_and_non(), nmg_dangling_face(), nmg_decompose_shell(), nmg_demote_lu(), nmg_does_fu_use_eg(), nmg_dump_model(), nmg_dup_loop(), nmg_dup_shell(), nmg_eu_2s_orient_bad(), nmg_eu_is_part_of_crack(), nmg_eval_shell(), nmg_extrude_face(), nmg_face_coincident_vu_sort(), nmg_face_fix_radial_parity(), nmg_face_lu_plot(), nmg_face_state_transition(), nmg_find_eg_between_2fg(), nmg_find_eu_with_vu_in_lu(), nmg_find_max_index(), nmg_find_next_use_of_2e_in_lu(), nmg_find_repeated_v_in_lu(), nmg_find_top_face_in_dir(), nmg_fix_overlapping_loops(), nmg_fu_planeeqn(), nmg_fu_touchingloops(), nmg_get_interior_pt(), nmg_get_touching_jaunts(), nmg_glue_face_in_shell(), nmg_hollow_shell(), nmg_intersect_loops_self(), nmg_is_crack_outie(), nmg_isect_2faceuse(), nmg_isect_eu_fu(), nmg_isect_face3p_shell_int(), nmg_isect_potcut_fu(), nmg_isect_vert2p_face2p(), nmg_jl(), nmg_join_2loops(), nmg_join_2singvu_loops(), nmg_join_singvu_loop(), nmg_join_touchingloops(), nmg_js(), nmg_keu(), nmg_keu_zl(), nmg_kill_accordions(), nmg_kill_cracks(), nmg_kill_cracks_at_vertex(), nmg_kill_non_common_cracks(), nmg_kill_snakes(), nmg_kill_zero_length_edgeuses(), nmg_klu(), nmg_loop_g(), nmg_loop_is_a_crack(), nmg_loop_plane_area(), nmg_loop_plane_area2(), nmg_loop_plane_newell(), nmg_loop_split_at_touching_jaunt(), nmg_lu_is_convex(), nmg_lu_reorient(), nmg_lu_to_vlist(), nmg_m_reindex(), nmg_m_set_high_bit(), nmg_m_struct_count(), nmg_meonvu(), nmg_mf(), nmg_mk_new_face_from_loop(), nmg_move_edge_thru_pt(), nmg_move_lu_between_fus(), nmg_moveltof(), nmg_mv_lu_between_shells(), nmg_no_isect_fu_pl(), nmg_open_shells_connect(), nmg_pl_edges_in_2_shells(), nmg_pl_isect(), nmg_plot_lu_ray(), nmg_plot_open_edges(), nmg_pr_lu(), nmg_pr_lu_briefly(), nmg_pr_one_eu_vecs(), nmg_propagate_normals(), nmg_purge_unwanted_intersection_points(), nmg_rebound(), nmg_reclassify_lu_eu(), nmg_remove_short_eus_inter(), nmg_reverse_face_and_radials(), nmg_reverse_radials(), nmg_rm_redundancies(), nmg_sanitize_fu(), nmg_set_lu_orientation(), nmg_show_each_loop(), nmg_simplify_loop(), nmg_simplify_shell_edges(), nmg_snurb_calc_lu_uv_orient(), nmg_split_loops_handler(), nmg_split_lu_at_vu(), nmg_split_touchingloops(), nmg_tabulate_face_g_verts(), nmg_to_poly(), nmg_to_tgc(), nmg_translate_face(), nmg_tri_kill_accordions(), nmg_triangulate_fu(), nmg_triangulate_rm_degen_loopuse(), nmg_triangulate_rm_holes(), nmg_uv_in_lu(), nmg_visit_loopuse(), nmg_vlblock_lu(), nmg_vlblock_s(), nmg_vloop(), nmg_vlu(), nmg_vu_angle_measure(), print_loopuse_tree(), rt_arb_tnurb(), rt_ehy_tess(), rt_ell_tnurb(), rt_hyp_tess(), rt_nmg_edisk(), rt_nmg_idisk(), rt_tgc_tess(), rt_tgc_tnurb(), Shell_is_arb(), tesselate_pipe_end(), tesselate_pipe_start(), and validate_tbl2d().

else bu_bomb ( "nmg_eusplit() bad lu->up\n"  )
NMG_CK_SHELL ( s  )

Referenced by _ged_get_solid_keypoint(), ged_fracture(), nmg_2_vrml(), nmg_add_loop_to_face(), nmg_assoc_void_shells(), nmg_bad_face_normals(), nmg_bot(), nmg_break_crossed_loops(), nmg_break_long_edges(), nmg_cface(), nmg_check_closed_shell(), nmg_check_radial(), nmg_check_radial_angles(), nmg_ck_closed_surf(), nmg_ck_fu(), nmg_class_pt_s(), nmg_class_ray_vs_shell(), nmg_class_shells(), nmg_close_shell(), nmg_cmface(), nmg_crackshells(), nmg_decompose_shell(), nmg_demote_eu(), nmg_demote_lu(), nmg_do_bool(), nmg_dump_model(), nmg_dup_face(), nmg_dup_shell(), nmg_eu_2s_orient_bad(), nmg_eval_shell(), nmg_evaluate_boolean(), nmg_extrude_cleanup(), nmg_extrude_shell(), nmg_face_fix_radial_parity(), nmg_find_e(), nmg_find_fu_with_fg_in_s(), nmg_find_matching_eu_in_s(), nmg_find_max_index(), nmg_find_outer_and_void_shells(), nmg_find_pt_in_shell(), nmg_find_top_face_in_dir(), nmg_findeu(), nmg_fix_decomposed_shell_normals(), nmg_fix_normals(), nmg_fix_overlapping_loops(), nmg_follow_free_edges_to_vertex(), nmg_glue_face_in_shell(), nmg_hollow_shell(), nmg_intersect_loops_self(), nmg_invert_shell(), nmg_is_vertex_a_selfloop_in_shell(), nmg_isect_face3p_shell_int(), nmg_isect_ray_shell(), nmg_isect_shell_self(), nmg_js(), nmg_keu_zl(), nmg_kfu(), nmg_kill_cracks(), nmg_kill_non_common_cracks(), nmg_kill_zero_length_edgeuses(), nmg_ks(), nmg_m_reindex(), nmg_m_set_high_bit(), nmg_m_struct_count(), nmg_make_connect_faces(), nmg_make_faces_within_tol(), nmg_manifolds(), nmg_me(), nmg_mesh_face_shell(), nmg_mesh_shell_shell(), nmg_mf(), nmg_mk_new_face_from_loop(), nmg_ml(), nmg_moveltof(), nmg_mv_shell_to_region(), nmg_next_radial_eu(), nmg_open_shells_connect(), nmg_pl_edges_in_2_shells(), nmg_pl_isect(), nmg_pr_one_eu_vecs(), nmg_prev_radial_eu(), nmg_r_radial_check(), nmg_radial_check_parity(), nmg_radial_face_count(), nmg_radial_find_an_original(), nmg_radial_mark_flips(), nmg_rebound(), nmg_rm_redundancies(), nmg_s_join_touchingloops(), nmg_s_radial_check(), nmg_s_radial_harmonize(), nmg_s_split_touchingloops(), nmg_s_to_vlist(), nmg_sanitize_s_lv(), nmg_shell_a(), nmg_shell_area(), nmg_shell_is_empty(), nmg_shell_is_void(), nmg_shell_manifolds(), nmg_show_each_loop(), nmg_simplify_shell(), nmg_simplify_shell_edges(), nmg_to_arb(), nmg_to_tgc(), nmg_triangulate_shell(), nmg_vfu(), nmg_visit_shell(), nmg_vlblock_s(), nmg_vlist_to_wire_edges(), nmg_vsshell(), rt_nmg_edisk(), rt_nmg_idisk(), Shell_is_arb(), tesselate_pipe_bend(), tesselate_pipe_end(), tesselate_pipe_linear(), and tesselate_pipe_start().

if ( )

Definition at line 3868 of file nmg_mod.c.

References nmg_me().

Here is the call graph for this function:

nmg_movevu ( eu2->  vu_p,
eu1->vu_p->  v_p 
)
if ( oldeu->g.magic_p!  = oldeu->eumate_p->g.magic_p)

Definition at line 3961 of file nmg_mod.c.

Variable Documentation

BU_LIST_INIT & oldeumate

Definition at line 3837 of file nmg_mod.c.

goto out

Definition at line 3846 of file nmg_mod.c.

Referenced by _db_recurse_subtree(), bn_dist_line3_pt3(), bn_distsq_line3_pt3(), bn_isect_line2_lseg2(), bn_isect_lseg3_lseg3(), bn_mat_dup(), bu_bitv_and(), bu_bitv_or(), bu_cv_w_cookie(), combine_loops(), construct_loops_from_segments(), containsNearHit(), containsNearMiss(), db_follow_path(), db_recurse(), db_rename(), SSICurve::Duplicate(), TrimmedFace::Duplicate(), find_similar_segments(), get_joinable_ssi_curves(), get_loop_points(), get_op_segments(), get_subcurves_inside_faces(), icv_rgb2gray(), innerloops_inside_outerloop(), interval_2d_to_2uv(), Overlapevent::IsPointIn(), light_hit(), link_curves(), loop_boolean(), make_result_from_loops(), make_segments(), nmg_2lu_identical(), nmg_assess_eu(), nmg_boolean(), nmg_break_eu_on_v(), nmg_calc_face_plane(), nmg_class_pt_s(), nmg_cnurb_is_linear(), nmg_cut_loop(), nmg_cut_lu_into_coplanar_and_non(), nmg_dangling_face(), nmg_does_fu_use_eg(), nmg_edge_geom_isect_line(), nmg_eu_2s_orient_bad(), nmg_eval_action(), nmg_extrude_shell(), nmg_find_e(), nmg_find_eu_in_face(), nmg_findeu(), nmg_isect_edge2p_edge2p(), nmg_isect_eu_fu(), nmg_isect_line2_edge2p(), nmg_kill_anti_loops(), nmg_loop_is_a_crack(), nmg_loop_is_ccw(), nmg_loop_plane_area2(), nmg_no_isect_fu_pl(), nmg_repair_v_near_v(), nmg_snurb_is_planar(), nmg_split_lu_at_vu(), nmg_stash_model_to_file(), nmg_triangulate_rm_degen_loopuse(), nmg_wedge_class(), ShaderInstance::outgoing_connections(), pd(), pd_3(), pd_3line(), pd_3space(), pd_arc(), pd_circle(), pd_line(), pd_space(), pdv_3(), pdv_3line(), pdv_3space(), pkg_suckin(), point_loop_location(), reflectance(), rr_hit(), rr_render(), rt_arb_shot(), rt_arbn_shot(), rt_boolfinal(), rt_brep_shot(), rt_copy_sketch(), rt_fdiff(), rt_hf_shot(), rt_hlf_shot(), rt_hlf_vshot(), rt_metaball_shot(), rt_part_shot(), rt_pr_tree_val(), rt_revolve_shot(), rt_shootray(), rt_shootray_bundle(), rt_vshootray(), sh_stk_dosetup(), split_face_into_loops(), split_trimmed_face(), tables_new(), and wdb_put_internal().

BU_LIST_APPEND & oldeu
Initial value:
{
bu_log("nmg_eusplit() in %s at %d invalid edgeuse parent\n",
__FILE__, __LINE__)
void bu_log(const char *,...) _BU_ATTR_PRINTF12
Definition: log.c:176

Definition at line 3847 of file nmg_mod.c.

lu = oldeu->up.lu_p

Definition at line 3855 of file nmg_mod.c.

Referenced by _ged_get_solid_keypoint(), build_topo_list(), cut_unimonotone(), fix_halfs(), insert_above(), insert_node(), isect_ray_snurb_face(), nmg_2_vrml(), nmg_add_loop_to_face(), nmg_assess_vu(), nmg_assoc_void_shells(), nmg_bad_face_normals(), nmg_bot(), nmg_break_crossed_loops(), nmg_break_long_edges(), nmg_brep_face(), nmg_build_loopuse_tree(), nmg_calc_face_plane(), nmg_cface(), nmg_check_closed_shell(), nmg_ck_closed_surf(), nmg_ck_face_worthless_edges(), nmg_ck_fu(), nmg_ck_fu_verts(), nmg_class_pt_euvu(), nmg_class_pt_fu_except(), nmg_class_shells(), nmg_classify_s_vs_s(), nmg_close_shell(), nmg_cmface(), nmg_connect_same_fu_orients(), nmg_count_shell_kids(), nmg_cut_loop(), nmg_cut_lu_into_coplanar_and_non(), nmg_dangling_face(), nmg_decompose_shell(), nmg_dump_model(), nmg_dup_face(), nmg_dup_shell(), nmg_edge_collapse(), nmg_enlist_vu(), nmg_eu_is_part_of_crack(), nmg_eval_shell(), nmg_extrude_cleanup(), nmg_extrude_face(), nmg_extrude_shell(), nmg_face_bb(), nmg_face_coincident_vu_sort(), nmg_face_fix_radial_parity(), nmg_face_rs_init(), nmg_face_state_transition(), nmg_faces_are_radial(), nmg_faceuse_area(), nmg_find_eu_left_non_unit(), nmg_find_eu_leftvec(), nmg_find_max_index(), nmg_find_pt_in_face(), nmg_find_pt_in_shell(), nmg_find_repeated_v_in_lu(), nmg_find_top_face_in_dir(), nmg_find_v_in_face(), nmg_find_zero_length_edges(), nmg_flatten_face(), nmg_fu_planeeqn(), nmg_fu_touchingloops(), nmg_glue_face_in_shell(), nmg_gluefaces(), nmg_hollow_shell(), nmg_intersect_loops_self(), nmg_is_crack_outie(), nmg_is_edge_in_looplist(), nmg_is_loop_in_facelist(), nmg_is_vertex_a_selfloop_in_shell(), nmg_is_vertex_in_face(), nmg_is_vertex_in_looplist(), nmg_isect_2faceuse(), nmg_isect_eu_fu(), nmg_isect_potcut_fu(), nmg_js(), nmg_keu_zl(), nmg_kill_anti_loops(), nmg_kill_cracks(), nmg_kill_cracks_at_vertex(), nmg_kill_non_common_cracks(), nmg_kill_wire_edges(), nmg_kill_zero_length_edgeuses(), nmg_loop_g(), nmg_m_reindex(), nmg_m_set_high_bit(), nmg_m_struct_count(), nmg_make_connect_faces(), nmg_make_dualvu(), nmg_make_faces_at_vert(), nmg_meonvu(), nmg_move_edge_thru_pt(), nmg_no_isect_fu_pl(), nmg_open_shells_connect(), nmg_pl_fu(), nmg_pl_isect(), nmg_plot_fu(), nmg_plot_open_edges(), nmg_polytonmg(), nmg_pr_fu(), nmg_pr_fu_briefly(), nmg_pr_one_eu_vecs(), nmg_pr_s(), nmg_pr_s_briefly(), nmg_propagate_normals(), nmg_purge_unwanted_intersection_points(), nmg_radial_mark_cracks(), nmg_rebound(), nmg_remove_short_eus_inter(), nmg_reverse_face_and_radials(), nmg_reverse_radials(), nmg_rm_redundancies(), nmg_s_join_touchingloops(), nmg_s_split_touchingloops(), nmg_s_to_vlist(), nmg_sanitize_fu(), nmg_sanitize_s_lv(), nmg_shell_a(), nmg_shell_coplanar_face_merge(), nmg_show_each_loop(), nmg_simplify_face(), nmg_simplify_shell_edges(), nmg_split_loops_handler(), nmg_tabulate_face_g_verts(), nmg_to_arb(), nmg_to_poly(), nmg_to_tgc(), nmg_translate_face(), nmg_triangulate_fu(), nmg_triangulate_rm_degen_loopuse(), nmg_visit_faceuse(), nmg_visit_shell(), nmg_vlblock_fu(), nmg_vlblock_s(), nmg_vlu(), nmg_vu_angle_measure(), rt_arb_tnurb(), rt_dsp_tess(), rt_ehy_tess(), rt_ell_tnurb(), rt_hyp_tess(), rt_nmg_edisk(), rt_nmg_get(), rt_nmg_ialloc(), rt_nmg_idisk(), rt_tgc_tess(), rt_tgc_tnurb(), rt_vol_tess(), Shell_is_arb(), tesselate_pipe_bend(), tesselate_pipe_end(), tesselate_pipe_linear(), tesselate_pipe_start(), and triangulateFace().

else if lu s = lu->up.s_p

Definition at line 3860 of file nmg_mod.c.

Referenced by _ged_get_solid_keypoint(), add_solid(), ConstantPool< ustring >::alloc(), bbd_setup(), bn_cx_div(), bn_mat_scale_about_pt(), bn_math_cmd(), bn_multipoly_add(), bn_multipoly_new(), bn_multipoly_set(), bn_noise_vec(), bn_tabdata_resample_avg(), bn_tabdata_resample_max(), bot2soup(), brep_face_info(), brep_facecdt_plot(), brep_surface_bezier_info(), brep_surface_info(), brep_surfaceleafs_plot(), brep_to_nmg(), bu_b64_decode_block(), bu_b64_encode_block(), bu_fgets(), bu_struct_export(), chull3d_build_convex_hull(), chull3d_check_simplex(), chull3d_connect(), chull3d_extend_simplices(), chull3d_search(), NurbsTools::computeMean(), db_dirhash(), do_region_end(), NurbsTools::downsample_random(), edge_hit_ray_state(), findfunction(), fix_halfs(), flip_short(), gcv_region_end(), gcv_region_end_mc(), ged_bot_fuse(), ged_decompose(), ged_facetize(), ged_fracture(), ged_make(), ged_nmg_fix_normals(), ged_nmg_simplify(), ged_shells(), getEdgePoints(), getSurfacePoints(), grass_render(), icv_filter3(), FittingSurface::initNurbsPCA(), FittingSurface::initNurbsPCABoundingBox(), invert(), joint_selection(), memset(), nmg_2_vrml(), nmg_assoc_void_shells(), nmg_check_radial(), nmg_ck_closed_region(), nmg_cnurb_to_vlist(), nmg_count_shell_kids(), nmg_demote_eu(), nmg_demote_lu(), nmg_do_bool(), nmg_dump_model(), nmg_edge_fuse(), nmg_eu_2s_orient_bad(), nmg_extrude_shell(), nmg_face_fix_radial_parity(), nmg_find_max_index(), nmg_find_outer_and_void_shells(), nmg_find_pt_in_model(), nmg_kfu(), nmg_kill_zero_length_edgeuses(), nmg_m_reindex(), nmg_m_set_high_bit(), nmg_m_struct_count(), nmg_mc_evaluate(), nmg_me(), nmg_meonvu(), nmg_merge_regions(), nmg_mf(), nmg_mirror_model(), nmg_mk_new_face_from_loop(), nmg_ml(), nmg_mlv(), nmg_model_fuse(), nmg_msv(), nmg_pl_edges_in_2_shells(), nmg_polytonmg(), nmg_pr_one_eu_vecs(), nmg_pr_r(), nmg_r_radial_check(), nmg_r_to_vlist(), nmg_radial_face_edge_in_shell(), nmg_rebound(), nmg_region_a(), nmg_region_area(), nmg_region_end(), nmg_to_arb(), nmg_to_poly(), nmg_to_tgc(), nmg_triangulate_model(), nmg_visit_region(), nmg_vlblock_r(), nmg_vshell(), cad::gcv::obj::output_formatter(), NurbsTools::pca(), pkg_pshort(), pullback_samples(), pullback_samples_from_closed_surface(), quat_mat2quat(), rfft(), rt_arb_shot(), rt_arb_tess(), rt_arb_tnurb(), rt_arb_vshot(), rt_arbn_shot(), rt_arbn_tess(), rt_ars_prep(), rt_ars_tess(), rt_binunif_adjust(), rt_bot_tess(), rt_brep_find_selections(), rt_brep_shot(), rt_cline_tess(), rt_dsp_tess(), rt_ebm_plate(), rt_ebm_tess(), rt_ehy_tess(), rt_ell_tnurb(), rt_epa_tess(), rt_eto_tess(), rt_extrude_tess(), rt_hf_shot(), rt_hyp_tess(), rt_metaball_tess(), rt_nmg_adjust(), rt_nmg_brep(), rt_nmg_centroid(), rt_nmg_edisk(), rt_nmg_get(), rt_nmg_ialloc(), rt_nmg_idisk(), rt_nmg_mirror(), rt_nmg_surf_area(), rt_nmg_volume(), rt_nurb_bbox(), rt_nurb_bezier(), rt_nurb_doolittle(), rt_nurb_export4(), rt_nurb_export5(), rt_nurb_free(), rt_nurb_import4(), rt_nurb_import5(), rt_nurb_plot(), rt_nurb_prep(), rt_nurb_shot(), rt_nurb_solve(), rt_part_norm(), rt_pg_tess(), rt_pipe_tess(), rt_pnts_export5(), rt_pnts_import5(), rt_rhc_tess(), rt_rpc_tess(), rt_tgc_tess(), rt_tgc_tnurb(), rt_tor_tess(), rt_vol_plate(), rt_vol_tess(), FrameBufferManipulator::setTransformation(), split_face_into_loops(), splitdit(), strsep(), strtok(), test_nmg_msv(), verbIn(), and cad::gcv::obj::verbose_output_formatter().

else
Initial value:
{
eu1 = nmg_me((struct vertex *)NULL, (struct vertex *)NULL, s)
if lu s
Definition: nmg_mod.c:3860
BU_LIST_DEQUEUE & eu1
Definition: nmg_mod.c:3839
struct edgeuse * nmg_me(struct vertex *v1, struct vertex *v2, struct shell *s)
Definition: nmg_mk.c:698

Definition at line 3872 of file nmg_mod.c.

eu2 up magic_p = oldeu->up.magic_p
oldeu eumate_p = oldeumate

Definition at line 3922 of file nmg_mod.c.

Referenced by rt_nmg_edisk(), and rt_nmg_idisk().

oldeu radial_p = oldeumate

Definition at line 3930 of file nmg_mod.c.

Referenced by rt_nmg_edisk(), and rt_nmg_idisk().

eu2 e_p = eu1->e_p