void do_quad(char *line) { int element_id; int pt1, pt2, pt3, pt4; fastf_t thick = 0.0; int pos = 0; bu_strlcpy(field, &line[8], sizeof(field)); element_id = atoi( field ); if ( debug ) bu_log( "do_quad: %s\n", line ); if ( !bot ) bot = element_id; if ( faces == NULL ) { faces = (int *)bu_malloc( GRID_BLOCK*3*sizeof( int ), "faces" ); thickness = (fastf_t *)bu_malloc( GRID_BLOCK*sizeof( fastf_t ), "thickness" ); facemode = (char *)bu_malloc( GRID_BLOCK*sizeof( char ), "facemode" ); face_size = GRID_BLOCK; face_count = 0; } bu_strlcpy(field, &line[24], sizeof(field)); pt1 = atoi( field ); bu_strlcpy(field, &line[32], sizeof(field)); pt2 = atoi( field ); bu_strlcpy(field, &line[40], sizeof(field)); pt3 = atoi( field ); bu_strlcpy(field, &line[48], sizeof(field)); pt4 = atoi( field ); if ( mode == PLATE_MODE ) { bu_strlcpy(field, &line[56], sizeof(field)); thick = atof( field ) * 25.4; bu_strlcpy(field, &line[64], sizeof(field)); pos = atoi( field ); if ( pos == 0 ) /* use default */ pos = POS_FRONT; if ( pos != POS_CENTER && pos != POS_FRONT ) { bu_log( "do_quad: illegal postion parameter (%d), must be one or two\n", pos ); bu_log( "\telement %d, component %d, group %d\n", element_id, comp_id, group_id ); return; } } Add_bot_face( pt1, pt2, pt3, thick, pos ); Add_bot_face( pt1, pt3, pt4, thick, pos ); }
icv_image_t * icv_create(int width, int height, ICV_COLOR_SPACE color_space) { icv_image_t *bif; BU_ALLOC(bif, struct icv_image); bif->width = width; bif->height = height; bif->color_space = color_space; bif->alpha_channel = 0; bif->magic = ICV_IMAGE_MAGIC; switch (color_space) { case ICV_COLOR_SPACE_RGB : /* Add all the other three channel images here (eg. HSV, YCbCr etc.) */ bif->data = (double *) bu_malloc(bif->height*bif->width*3*sizeof(double), "Image Data"); bif->channels = 3; break; case ICV_COLOR_SPACE_GRAY : bif->data = (double *) bu_malloc(bif->height*bif->width*1*sizeof(double), "Image Data"); bif->channels = 1; break; default : bu_exit(1, "icv_create_image : Color Space Not Defined"); break; } return icv_zero(bif); }
void Readpoints(void) { struct points *ptr, *prev; fastf_t x, y, z; ptr = root; prev = NULL; printf( "X Y Z (^D for end): "); while (scanf("%lf%lf%lf", &x, &y, &z) == 3 ) { if ( ptr == NULL ) { ptr = (struct points *)bu_malloc( sizeof( struct points ), "ptr" ); root = ptr; } else { ptr->next = (struct points *)bu_malloc( sizeof( struct points ), "ptr->next" ); ptr = ptr->next; } ptr->next = NULL; ptr->prev = prev; prev = ptr; VSET(ptr->p, k*x, k*y, k*z); ptr->tube[0] = '\0'; ptr->tubflu[0] = '\0'; ptr->elbow[0] = '\0'; ptr->elbflu[0] = '\0'; ptr->cut[0] = '\0'; printf( "X Y Z (^D for end): "); } }
void texture_perlin_init(struct texture_perlin_s *P) { int i, j, k; P->PV = (int *)bu_malloc(sizeof(int)*(2*B+2), "PV"); P->RV = (vect_t *)bu_malloc(sizeof(vect_t)*(2*B+2), "RV"); /* Generate Random Vectors */ for (i = 0; i < B; i++) { P->RV[i][0] = (fastf_t)((PRAND % (2*B)) - B) / B; P->RV[i][1] = (fastf_t)((PRAND % (2*B)) - B) / B; P->RV[i][2] = (fastf_t)((PRAND % (2*B)) - B) / B; VUNITIZE(P->RV[i]); P->PV[i] = i; } /* Permute Indices into Vector List G */ for (i = 0; i < B; i++) { k = P->PV[i]; P->PV[i] = P->PV[j = PRAND % B]; P->PV[j] = k; } for (i = 0; i < B + 2; i++) { P->PV[B+i] = P->PV[i]; VMOVE(P->RV[B+i], P->RV[i]); } }
void db_dup_full_path(struct db_full_path *newp, const struct db_full_path *oldp) { unsigned int i = 0; RT_CK_FULL_PATH(newp); RT_CK_FULL_PATH(oldp); newp->fp_maxlen = oldp->fp_maxlen; newp->fp_len = oldp->fp_len; if (oldp->fp_len <= 0) { newp->fp_names = (struct directory **)0; newp->fp_bool = (int *)0; return; } newp->fp_names = (struct directory **)bu_malloc(newp->fp_maxlen * sizeof(struct directory *), "db_full_path array (duplicate)"); memcpy((char *)newp->fp_names, (char *)oldp->fp_names, newp->fp_len * sizeof(struct directory *)); newp->fp_bool = (int *)bu_malloc(newp->fp_maxlen * sizeof(int), "db_full_path bool array (duplicate)"); memcpy((char *)newp->fp_bool, (char *)oldp->fp_bool, newp->fp_len * sizeof(int)); newp->fp_mat = (matp_t *)bu_calloc(newp->fp_maxlen, sizeof(matp_t), "db_full_path mat array (duplicate)"); for (i = 0; i < newp->fp_len; i++) { if (oldp->fp_mat[i]) { newp->fp_mat[i] = (matp_t)bu_calloc(1, sizeof(mat_t), "transformation matrix"); MAT_COPY(newp->fp_mat[i], oldp->fp_mat[i]); } } }
static struct edge_g_cnurb * nmg_construct_edge_g_cnurb(const struct edge_g_cnurb *original, void **structArray) { struct edge_g_cnurb *ret; NMG_GETSTRUCT(ret, edge_g_cnurb); ret->l.magic = NMG_EDGE_G_CNURB_MAGIC; BU_LIST_INIT(&ret->eu_hd2); ret->order = original->order; ret->k.magic = NMG_KNOT_VECTOR_MAGIC; ret->k.k_size = original->k.k_size; ret->k.knots = (fastf_t *)bu_malloc(ret->k.k_size * sizeof(fastf_t), "nmg_construct_edge_g_cnurb(): k.knots"); memcpy(ret->k.knots, original->k.knots, ret->k.k_size * sizeof(fastf_t)); ret->c_size = original->c_size; ret->pt_type = original->pt_type; ret->ctl_points = (fastf_t *)bu_malloc(ret->c_size * RT_NURB_EXTRACT_COORDS(ret->pt_type) * sizeof(fastf_t), "nmg_construct_edge_g_cnurb(): ctl_points"); memcpy(ret->ctl_points, original->ctl_points, ret->c_size * RT_NURB_EXTRACT_COORDS(ret->pt_type) * sizeof(fastf_t)); ret->index = original->index; structArray[ret->index] = ret; return ret; }
/* * Write the nmg to a BRL-CAD style data base. */ int create_brlcad_db(struct rt_wdb *fpout, struct model *m, char *reg_name, char *grp_name) { char *rname, *sname; int empty_model; struct shell *s; struct nmgregion *r; rname = (char *)bu_malloc(sizeof(reg_name) + 3, "rname"); /* Region name. */ sname = (char *)bu_malloc(sizeof(reg_name) + 3, "sname"); /* Solid name. */ snprintf(sname, sizeof(reg_name) + 2, "s.%s", reg_name); empty_model = nmg_kill_zero_length_edgeuses(m); if (empty_model) { bu_log("Warning: skipping empty model."); return 0; } nmg_rebound(m, &tol); r = BU_LIST_FIRST(nmgregion, &m->r_hd); s = BU_LIST_FIRST(shell, &r->s_hd); mk_bot_from_nmg(fpout, sname, s); /* Make BOT object. */ snprintf(rname, sizeof(reg_name) + 2, "r.%s", reg_name); mk_comb1(fpout, rname, sname, 1); /* Put object in a region. */ if (grp_name) { mk_comb1(fpout, grp_name, rname, 1); /* Region in group. */ } return 0; }
/** * Create a place holder for a nurb surface. */ struct face_g_snurb * rt_nurb_new_snurb(int u_order, int v_order, int n_u, int n_v, int n_rows, int n_cols, int pt_type, struct resource *res) { register struct face_g_snurb * srf; int pnum; if (res) RT_CK_RESOURCE(res); GET_SNURB(srf); srf->order[0] = u_order; srf->order[1] = v_order; srf->dir = RT_NURB_SPLIT_ROW; srf->u.k_size = n_u; srf->v.k_size = n_v; srf->s_size[0] = n_rows; srf->s_size[1] = n_cols; srf->pt_type = pt_type; pnum = sizeof (fastf_t) * n_rows * n_cols * RT_NURB_EXTRACT_COORDS(pt_type); srf->u.knots = (fastf_t *) bu_malloc ( n_u * sizeof (fastf_t), "rt_nurb_new_snurb: u kv knot values"); srf->v.knots = (fastf_t *) bu_malloc ( n_v * sizeof (fastf_t), "rt_nurb_new_snurb: v kv knot values"); srf->ctl_points = (fastf_t *) bu_malloc( pnum, "rt_nurb_new_snurb: control mesh points"); return srf; }
/* This attempts to find the surface area by subdividing the uv plane * into squares, and finding the approximate surface area of each * square. */ static fastf_t superell_surf_area_general(const struct rt_superell_internal *sip, vect_t mags, fastf_t side_length) { fastf_t area = 0; fastf_t u, v; /* There are M_PI / side_length + 1 values because both ends have to be stored */ int row_length = sizeof(point_t) * (M_PI / side_length + 1); point_t *row1 = (point_t *)bu_malloc(row_length, "superell_surf_area_general"); point_t *row2 = (point_t *)bu_malloc(row_length, "superell_surf_area_general"); int idx = 0; /* This function keeps a moving window of two rows at any time, * and calculates the area of space between those two rows. It * calculates the first row outside of the loop so that at each * iteration it only has to calculate the second. Following * standard definitions of u and v, u ranges from -pi to pi, and v * ranges from -pi/2 to pi/2. Using an extra index variable allows * the code to compute the index into the array very efficiently. */ for (v = -M_PI_2; v < M_PI_2; v += side_length, idx++) { superell_xyz_from_uv(row1[idx], -M_PI, v, mags, sip); } /* This starts at -M_PI + side_length because the first row is * computed outside the loop, which allows the loop to always * calculate the second row of the pair. */ for (u = -M_PI + side_length; u < M_PI; u += side_length) { idx = 0; for (v = -M_PI_2; v < M_PI_2; v += side_length, idx++) { superell_xyz_from_uv(row2[idx], u + side_length, v, mags, sip); } idx = 0; /* This ends at -M_PI / 2 - side_length because if it kept * going it would overflow the array, since it always looks at * the square to the right of its current index. */ for (v = - M_PI_2; v < M_PI_2 - side_length; v += side_length, idx++) { area += bn_dist_pt3_pt3(row1[idx], row1[idx + 1]) * bn_dist_pt3_pt3(row1[idx], row2[idx]); } memcpy(row1, row2, row_length); } bu_free(row1, "superell_surf_area_general"); bu_free(row2, "superell_surf_area_general"); return area; }
HIDDEN int wdb_add_operand(Tcl_Interp *interp, struct bu_list *hp, char *name) { char *ptr_lparen; char *ptr_rparen; int name_len; union tree *node; struct tokens *tok; BU_CK_LIST_HEAD(hp); ptr_lparen = strchr(name, '('); ptr_rparen = strchr(name, ')'); RT_GET_TREE( node, &rt_uniresource ); node->magic = RT_TREE_MAGIC; node->tr_op = OP_DB_LEAF; node->tr_l.tl_mat = (matp_t)NULL; if (ptr_lparen || ptr_rparen) { int tmp1, tmp2; if (ptr_rparen) tmp1 = ptr_rparen - name; else tmp1 = (-1); if (ptr_lparen) tmp2 = ptr_lparen - name; else tmp2 = (-1); if (tmp2 == (-1) && tmp1 > 0) name_len = tmp1; else if (tmp1 == (-1) && tmp2 > 0) name_len = tmp2; else if (tmp1 > 0 && tmp2 > 0) { if (tmp1 < tmp2) name_len = tmp1; else name_len = tmp2; } else { Tcl_AppendResult(interp, "Cannot determine length of operand name: ", name, ", aborting\n", (char *)NULL); return (0); } } else name_len = strlen( name ); node->tr_l.tl_name = (char *)bu_malloc(name_len+1, "node name"); bu_strlcpy(node->tr_l.tl_name, name, name_len+1); tok = (struct tokens *)bu_malloc(sizeof(struct tokens), "tok"); tok->type = WDB_TOK_TREE; tok->tp = node; BU_LIST_INSERT(hp, &tok->l); return (name_len); }
void render_surfel_init(render_t *render, uint32_t num, render_surfel_pt_t *list) { render_surfel_t *d; render->work = render_surfel_work; render->free = render_surfel_free; render->data = (render_surfel_t *)bu_malloc(sizeof(render_surfel_t), "render data"); d = (render_surfel_t *)render->data; d->list = (render_surfel_pt_t *)bu_malloc(num * sizeof(render_surfel_pt_t), "data list"); d->num = num; d->list = list; }
/** * rt_nurb_c_xsplit() * * Split a NURB curve by inserting a multiple knot and return the * result of the two curves. * * Algorithm: * * Insert a multiple knot of the curve order. A parameter is give for * the knot value for which the curve will be split. */ struct edge_g_cnurb * rt_nurb_c_xsplit(struct edge_g_cnurb *crv, fastf_t param) { struct knot_vector new_kv; struct oslo_mat * oslo; int k_index; struct edge_g_cnurb * crv1, * crv2; int coords; NMG_CK_CNURB(crv); coords = RT_NURB_EXTRACT_COORDS(crv->pt_type), k_index = crv->order; rt_nurb_kvmult(&new_kv, &crv->k, crv->order, param, (struct resource *)NULL); oslo = (struct oslo_mat *) rt_nurb_calc_oslo(crv->order, &crv->k, &new_kv, (struct resource *)NULL); GET_CNURB(crv1); crv1->order = crv->order; rt_nurb_kvextract(&crv1->k, &new_kv, 0, k_index + crv->order, (struct resource *)NULL); crv1->pt_type = crv->pt_type; crv1->c_size = crv1->k.k_size - crv1->order; crv1->ctl_points = (fastf_t *) bu_malloc(sizeof(fastf_t) * crv1->c_size * RT_NURB_EXTRACT_COORDS(crv1->pt_type), "rt_nurb_c_xsplit: crv1 control points"); GET_CNURB(crv2); crv2->order = crv->order; rt_nurb_kvextract(&crv2->k, &new_kv, k_index, new_kv.k_size, (struct resource *)NULL); crv2->pt_type = crv->pt_type; crv2->c_size = crv2->k.k_size - crv2->order; crv2->ctl_points = (fastf_t *) bu_malloc(sizeof(fastf_t) * crv2->c_size * RT_NURB_EXTRACT_COORDS(crv2->pt_type), "rt_nurb_c_xsplit: crv2 row mesh control points"); rt_nurb_map_oslo(oslo, crv->ctl_points, crv1->ctl_points, coords, coords, 0, k_index, crv->pt_type); rt_nurb_map_oslo(oslo, crv->ctl_points, crv2->ctl_points, coords, coords, k_index, new_kv.k_size - crv2->order, crv2->pt_type); rt_nurb_free_oslo(oslo, (struct resource *)NULL); bu_free((char *) new_kv.knots, "rt_nurb_c_xsplit: new_kv.knots"); BU_LIST_APPEND(&crv1->l, &crv2->l); return crv1; }
/** * Solve must be passed two matrices that are of the form of pointer * to double arrays. mat_1 is the n by n matrix that is to be * decomposed and mat_2 is the matrix that contains the left side of * the equation. The variable solution which is double is also to be * created by the user and consisting of n elements of which the * solution set is passed back. * * Arguments mat_1 and mat_2 are modified by this call. * The solution is written into the solution[] array. */ void rt_nurb_solve(fastf_t *mat_1, fastf_t *mat_2, fastf_t *solution, int dim, int coords) /* A and b array of the system Ax= b*/ /* dimension of the matrix */ /* Number of coordinates for mat_2 and solution */ { register int i, k; fastf_t *y; fastf_t * b; fastf_t * s; y = (fastf_t *) bu_malloc(sizeof (fastf_t) * dim, "rt_nurb_solve: y");/* Create temp array */ b = (fastf_t *) bu_malloc(sizeof (fastf_t) * dim, "rt_nurb_solve: b");/* Create temp array */ s = (fastf_t *) bu_malloc(sizeof (fastf_t) * dim, "rt_nurb_solve: s");/* Create temp array */ rt_nurb_doolittle (mat_1, mat_2, dim, coords);/* Create LU decomposition */ for (k =0; k < coords; k++) { fastf_t * ptr; ptr = mat_2 + k; for (i = 0; i < dim; i++) { b[i] = *ptr; ptr += coords; } /* Solve the system Ly =b */ rt_nurb_forw_solve (mat_1, b, y, dim); /* Solve the system Ux = y */ rt_nurb_back_solve (mat_1, y, s, dim); ptr = solution + k; for (i=0; i < dim; i++) { *ptr = s[i]; ptr += coords; } } bu_free ((char *)y, "rt_nurb_solve: y"); /* Free up storage */ bu_free ((char *)b, "rt_nurb_solve: b"); /* Free up storage */ bu_free ((char *)s, "rt_nurb_solve: s"); /* Free up storage */ }
void texture_image_init(texture_t *texture, short w, short h, unsigned char *image) { texture_image_t *td; texture->data = bu_malloc(sizeof(texture_image_t), "texture data"); texture->free = texture_image_free; texture->work = (texture_work_t *)texture_image_work; td = (texture_image_t *)texture->data; td->w = w; td->h = h; td->image = (unsigned char *)bu_malloc(3*w*h, "texture image"); memcpy(td->image, image, 3*w*h); }
/** * P O P _ I N I T --- initialize a population of a given size */ void pop_init (struct population *p, int size) { p->parent = bu_malloc(sizeof(struct individual) * size, "parent"); p->child = bu_malloc(sizeof(struct individual) * size, "child"); p->size = size; p->db_c = p->db_p = DBI_NULL; p->name = bu_malloc(sizeof(char *) * size, "names"); #define SEED 33 /* init in main() bn_rand_init(randomer, SEED);*/ bn_rand_init(randomer, SEED); }
/* bn_gauss_init Initialize a random number struct for gaussian * numbers. * * @par Entry * setseed Seed to use. * method method to use to generate numbers (not used) * * @par Exit * Returns a pointer toa bn_msr_guass structure. * returns 0 on error. * * @par Calls * bu_malloc * * @par Uses * None. * * @par Method @code * malloc up a structure * get table space * set seed and pointer. * if setseed != 0 then seed = setseed @endcode */ struct bn_gauss * bn_gauss_init(long int setseed, int method) { struct bn_gauss *p; p = (struct bn_gauss *) bu_malloc(sizeof(struct bn_gauss), "bn_msr_guass"); p->msr_gausses=(double *) bu_malloc(BN_MSR_MAXTBL*sizeof(double), "msr guass table"); p->msr_gauss_doubles=(double *) bu_malloc(BN_MSR_MAXTBL*sizeof(double), "msr guass doubles"); p->msr_gauss_seed = 1; p->msr_gauss_ptr = 0; p->msr_gauss_dbl_ptr = 0; if (setseed&0x7fffffff) p->msr_gauss_seed=setseed&0x7fffffff; p->magic = BN_GAUSS_MAGIC; return(p); }
/** * b u _ v l s _ e x t e n d * * Ensure that the provided VLS has at least 'extra' characters of * space available. */ void bu_vls_extend(register struct bu_vls *vp, unsigned int extra) { BU_CK_VLS(vp); /* increment by at least 40 bytes */ if ( extra < _VLS_ALLOC_MIN ) extra = _VLS_ALLOC_MIN; /* first time allocation */ if ( vp->vls_max <= 0 || vp->vls_str == (char *)0 ) { vp->vls_max = extra; vp->vls_str = (char *)bu_malloc( (size_t)vp->vls_max, bu_vls_message ); vp->vls_len = 0; vp->vls_offset = 0; *vp->vls_str = '\0'; return; } /* need more space? */ if ( vp->vls_offset + vp->vls_len + extra >= (size_t)vp->vls_max ) { vp->vls_max += extra; if ( vp->vls_max < _VLS_ALLOC_STEP ) { /* extend to at least this much */ vp->vls_max = _VLS_ALLOC_STEP; } vp->vls_str = (char *)bu_realloc( vp->vls_str, (size_t)vp->vls_max, bu_vls_message ); } }
int db_ls(const struct db_i *dbip, int flags, struct directory ***dpv) { int i; int objcount = 0; struct directory *dp; RT_CK_DBI(dbip); for (i = 0; i < RT_DBNHASH; i++) { for (dp = dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) { objcount += dp_eval_flags(dp, flags); } } if (objcount > 0) { (*dpv) = (struct directory **)bu_malloc(sizeof(struct directory *) * (objcount + 1), "directory pointer array"); objcount = 0; for (i = 0; i < RT_DBNHASH; i++) { for (dp = dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) { if (dp_eval_flags(dp,flags)) { (*dpv)[objcount] = dp; objcount++; } } } (*dpv)[objcount] = NULL; } return objcount; }
int main(int argc, char **argv) { point_t a, b, c, d; struct rt_wdb *fp; si.magic = RT_NURB_INTERNAL_MAGIC; si.nsrf = 0; si.srfs = (struct face_g_snurb **)bu_malloc( sizeof(struct face_g_snurb *)*100, "snurb ptrs"); if ((fp = wdb_fopen(argv[1])) == NULL) { bu_log("unable to open new database [%s]\n", argv[1]); perror("unable to open database file"); return 1; } mk_id( fp, "Mike's Spline Test" ); VSET( a, 0, 0, 0 ); VSET( b, 10, 0, 0 ); VSET( c, 10, 10, 0 ); VSET( d, 0, 10, 0 ); make_face( a, b, c, d, 2 ); mk_export_fwrite( fp, "spl", (genptr_t)&si, ID_BSPLINE ); return 0; }
/** * rt_nurb_kvmerge() * * Merge two knot vectors together and return the new resulting knot * vector. */ void rt_nurb_kvmerge(struct knot_vector *new_knots, const struct knot_vector *kv1, const struct knot_vector *kv2, struct resource *res) { int kv1_ptr = 0; int kv2_ptr = 0; int new_ptr; if (res) RT_CK_RESOURCE(res); new_knots->k_size = kv1->k_size + kv2->k_size; new_knots->knots = (fastf_t *) bu_malloc( sizeof (fastf_t) * new_knots->k_size, "rt_nurb_kvmerge: new knot values"); for (new_ptr = 0; new_ptr < new_knots->k_size; new_ptr++) { if (kv1_ptr >= kv1->k_size) new_knots->knots[new_ptr] = kv2->knots[kv2_ptr++]; else if (kv2_ptr >= kv2->k_size) new_knots->knots[new_ptr] = kv1->knots[kv1_ptr++]; else if (kv1->knots[kv1_ptr] < kv2->knots[kv2_ptr]) new_knots->knots[new_ptr] = kv1->knots[kv1_ptr++]; else new_knots->knots[new_ptr] = kv2->knots[kv2_ptr++]; } }
void db_add_node_to_full_path(struct db_full_path *pp, struct directory *dp) { RT_CK_FULL_PATH(pp); if (pp->fp_maxlen <= 0) { pp->fp_maxlen = 32; pp->fp_names = (struct directory **)bu_malloc( pp->fp_maxlen * sizeof(struct directory *), "db_full_path array"); pp->fp_bool = (int *)bu_calloc(pp->fp_maxlen, sizeof(int), "db_full_path bool array"); pp->fp_mat = (matp_t *)bu_calloc(pp->fp_maxlen, sizeof(matp_t), "db_full_path matrices array"); } else if (pp->fp_len >= pp->fp_maxlen) { pp->fp_maxlen *= 4; pp->fp_names = (struct directory **)bu_realloc( (char *)pp->fp_names, pp->fp_maxlen * sizeof(struct directory *), "enlarged db_full_path array"); pp->fp_bool = (int *)bu_realloc( (char *)pp->fp_bool, pp->fp_maxlen * sizeof(int), "enlarged db_full_path bool array"); pp->fp_mat = (matp_t *)bu_realloc( (char *)pp->fp_mat, pp->fp_maxlen * sizeof(matp_t), "enlarged db_full_path matrices array"); } pp->fp_names[pp->fp_len++] = dp; }
int db_argv_to_path(struct db_full_path *pp, struct db_i *dbip, int argc, const char *const *argv) { struct directory *dp; int ret = 0; int i; RT_CK_DBI(dbip); /* Make a path structure just big enough */ pp->magic = DB_FULL_PATH_MAGIC; pp->fp_maxlen = pp->fp_len = argc; pp->fp_names = (struct directory **)bu_malloc( pp->fp_maxlen * sizeof(struct directory *), "db_argv_to_path path array"); pp->fp_bool = (int *)bu_calloc(pp->fp_maxlen, sizeof(int), "db_argv_to_path bool array"); pp->fp_mat = (matp_t *)bu_calloc(pp->fp_maxlen, sizeof(matp_t), "db_string_to_path mat array"); for (i = 0; i<argc; i++) { if ((dp = db_lookup(dbip, argv[i], LOOKUP_NOISY)) == RT_DIR_NULL) { bu_log("db_argv_to_path() failed on element %d='%s'\n", i, argv[i]); ret = -1; /* FAILED */ /* Fall through, storing null dp in this location */ } pp->fp_names[i] = dp; } return ret; }
char * bu_strdupm(register const char *cp, const char *label) { char *base; size_t len; if (UNLIKELY(!cp && label)) { bu_semaphore_acquire(BU_SEM_SYSCALL); fprintf(stderr, "WARNING: [%s] NULL copy buffer\n", label); bu_semaphore_release(BU_SEM_SYSCALL); } if (!label) { label = "bu_strdup"; } len = strlen(cp)+1; base = (char *)bu_malloc(len, label); if (UNLIKELY(bu_debug&BU_DEBUG_MEM_LOG)) { bu_semaphore_acquire(BU_SEM_SYSCALL); fprintf(stderr, "%p strdup%llu \"%s\"\n", (void *)base, (unsigned long long)len, cp); bu_semaphore_release(BU_SEM_SYSCALL); } memcpy(base, cp, len); return base; }
void render_camera_init(render_camera_t *camera, int threads) { camera->type = RENDER_CAMERA_PERSPECTIVE; camera->view_num = 1; camera->view_list = (render_camera_view_t *) bu_malloc (sizeof(render_camera_view_t), "render_camera_init"); camera->dof = 0; camera->tilt = 0; /* The camera will use a thread for every cpu the machine has. */ camera->thread_num = threads ? threads : (uint8_t)bu_avail_cpus(); bu_semaphore_init(TIE_SEM_LAST); /* Initialize camera to rendering surface normals */ render_normal_init(&camera->render, NULL); camera->rm = RENDER_METHOD_PHONG; if (shaders == NULL) { #define REGISTER(x) render_shader_register((const char *)#x, render_##x##_init); REGISTER(component); REGISTER(cut); REGISTER(depth); REGISTER(flat); REGISTER(flos); REGISTER(grid); REGISTER(normal); REGISTER(path); REGISTER(phong); REGISTER(spall); REGISTER(surfel); #undef REGISTER } }
void Wgl_fb_open() { char *wgl_name = "/dev/wgl"; if ((fbp = (FBIO *)calloc(sizeof(FBIO), 1)) == FBIO_NULL) { Tcl_AppendResult(interp, "Wgl_fb_open: failed to allocate framebuffer memory\n", (char *)NULL); return; } *fbp = wgl_interface; /* struct copy */ fbp->if_name = bu_malloc((unsigned)strlen(wgl_name)+1, "if_name"); bu_strlcpy(fbp->if_name, wgl_name, strlen(wgl_name)+1); /* Mark OK by filling in magic number */ fbp->if_magic = FB_MAGIC; _wgl_open_existing(fbp, ((struct dm_xvars *)dmp->dm_vars.pub_vars)->dpy, ((struct dm_xvars *)dmp->dm_vars.pub_vars)->win, ((struct dm_xvars *)dmp->dm_vars.pub_vars)->cmap, ((struct dm_xvars *)dmp->dm_vars.pub_vars)->vip, ((struct dm_xvars *)dmp->dm_vars.pub_vars)->hdc, dmp->dm_width, dmp->dm_height, ((struct wgl_vars *)dmp->dm_vars.priv_vars)->glxc, ((struct wgl_vars *)dmp->dm_vars.priv_vars)->mvars.doublebuffer, 0); }
int main(int argc, char **argv) { int i; if (!get_args(argc, argv) || isatty(fileno(stdout))) { (void)fputs(usage, stderr); bu_exit (1, NULL); } if (inx <= 0 || iny <= 0 || outx <= 0 || outy <= 0) { fprintf(stderr, "bwscale: bad size\n"); bu_exit (2, NULL); } /* See how many lines we can buffer */ scanlen = inx; init_buffer(scanlen); i = (inx < outx) ? outx : inx; outbuf = (unsigned char *)bu_malloc(i, "outbuf"); /* Here we go */ scale(stdout, inx, iny, outx, outy); bu_free(outbuf, (const char *)buffer); bu_free(buffer, (const char *)buffer); return 0; }
/** * Using a single call to db_put(), write multiple zeroed records out, * all with u_id field set to ID_FREE. * This will zap all records from "start" to the end of this entry. * * Returns: * 0 on success (from db_put()) * non-zero on failure */ int db_zapper(struct db_i *dbip, struct directory *dp, size_t start) { union record *rp; size_t i; size_t todo; int ret; RT_CK_DBI(dbip); RT_CK_DIR(dp); if (RT_G_DEBUG&DEBUG_DB) bu_log("db_zapper(%s) %p, %p, start=%zu\n", dp->d_namep, (void *)dbip, (void *)dp, start); if (dp->d_flags & RT_DIR_INMEM) bu_bomb("db_zapper() called on RT_DIR_INMEM object\n"); if (dbip->dbi_read_only) return -1; BU_ASSERT_LONG(dbip->dbi_version, ==, 4); if (dp->d_len < start) return -1; if ((todo = dp->d_len - start) == 0) return 0; /* OK -- trivial */ rp = (union record *)bu_malloc(todo * sizeof(union record), "db_zapper buf"); memset((char *)rp, 0, todo * sizeof(union record)); for (i=0; i < todo; i++) rp[i].u_id = ID_FREE; ret = db_put(dbip, dp, rp, (off_t)start, todo); bu_free((char *)rp, "db_zapper buf"); return ret; }
/** * rt_nurb_kvknot() * * Generate a open knot vector with n=order knots at the beginning of * the sequence and n knots at the end of the sequence with a lower, * and an upper value and num knots in between */ void rt_nurb_kvknot(register struct knot_vector *new_knots, int order, fastf_t lower, fastf_t upper, int num, struct resource *res) { register int i; int total; fastf_t knot_step; if (res) RT_CK_RESOURCE(res); total = order * 2 + num; knot_step = (upper - lower) / (num + 1); new_knots->k_size = total; new_knots->knots = (fastf_t *) bu_malloc (sizeof(fastf_t) * total, "rt_nurb_kvknot: new knots values"); for (i = 0; i < order; i++) new_knots->knots[i] = lower; for (i = order; i <= (num + order - 1); i++) new_knots->knots[i] = new_knots->knots[i-1] + knot_step; for (i = (num + order); i < total; i++) new_knots->knots[i] = upper; }
/** * rt_nurb_kvmult() * * Construct a new knot vector which is the same as the passed in knot * vector except it has multiplicity of num of val. It checks to see * if val already is a multiple knot. */ void rt_nurb_kvmult(struct knot_vector *new_kv, const struct knot_vector *kv, int num, register fastf_t val, struct resource *res) { int n; register int i; struct knot_vector check; if (res) RT_CK_RESOURCE(res); n = rt_nurb_kvcheck(val, kv); check.k_size = num - n; if (check.k_size <= 0) { bu_log("rt_nurb_kvmult(new_kv=%p, kv=%p, num=%d, val=%g)\n", (void *)new_kv, (void *)kv, num, val); rt_nurb_pr_kv(kv); bu_bomb("rt_nurb_kvmult\n"); } check.knots = (fastf_t *) bu_malloc(sizeof(fastf_t) * check.k_size, "rt_nurb_kvmult: check knots"); for (i = 0; i < num - n; i++) check.knots[i] = val; rt_nurb_kvmerge(new_kv, &check, kv, res); /* free up old knot values */ bu_free((char *)check.knots, "rt_nurb_kvmult:check knots"); }
/** * The external format is: * V point * A vector * B vector * C vector */ int rt_superell_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip) { struct rt_superell_internal *eip; /* must be double for import and export */ double vec[ELEMENTS_PER_VECT*4 + 2]; if (dbip) RT_CK_DBI(dbip); RT_CK_DB_INTERNAL(ip); if (ip->idb_type != ID_SUPERELL) return -1; eip = (struct rt_superell_internal *)ip->idb_ptr; RT_SUPERELL_CK_MAGIC(eip); BU_CK_EXTERNAL(ep); ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE * (ELEMENTS_PER_VECT*4 + 2); ep->ext_buf = (uint8_t *)bu_malloc(ep->ext_nbytes, "superell external"); /* scale 'em into local buffer */ VSCALE(&vec[0*ELEMENTS_PER_VECT], eip->v, local2mm); VSCALE(&vec[1*ELEMENTS_PER_VECT], eip->a, local2mm); VSCALE(&vec[2*ELEMENTS_PER_VECT], eip->b, local2mm); VSCALE(&vec[3*ELEMENTS_PER_VECT], eip->c, local2mm); vec[4*ELEMENTS_PER_VECT] = eip->n; vec[4*ELEMENTS_PER_VECT + 1] = eip->e; /* Convert from internal (host) to database (network) format */ bu_cv_htond(ep->ext_buf, (unsigned char *)vec, ELEMENTS_PER_VECT*4 + 2); return 0; }