/*======== void add_edge() ==========
Inputs: struct matrix * points
int x0, int y0, int z0, int x1, int y1, int z1
Returns:
add the line connecting (x0, y0, z0) to (x1, y1, z1) to points
should call add_point
====================*/
void add_edge( struct matrix * points,
int x0, int y0, int z0,
int x1, int y1, int z1)
{
add_point(points, x0, y0, z0);
add_point(points, x1, y1, z1);
}
/*======== void generate_torus() ==========
Inputs: struct matrix * points
double cx
double cy
double r
double step
Returns:
Generates all the points along the surface of a
tarus with center (cx, cy) and radii r1 and r2
Adds these points to the matrix parameter
jdyrlandweaver
====================*/
void generate_torus( struct matrix * points,
double cx, double cy, double r1, double r2,
double step ) {
//t = θ = angle of circle generation
//p = ϕ = angle of circle rotation
double x0, y0, z0, x, y, z, t, p;
x0 = cx + r1;
y0 = cy;
z0 = 0;
for ( t = step; t <= 1; t+= step ) {
for ( p = step; p <= 1; p+= step ) {
x = r1 * cos( 2 * M_PI * t ) + cx;
y = cos( 2 * M_PI * p)*( r1 * sin( 2 * M_PI * t ) + r2) + cy;
z = sin( 2 * M_PI * p)*( r1 * sin( 2 * M_PI * t ) + r2) + 0;
add_point(points, x0, y0, z0);
x0 = x;
y0 = y;
z0 = z;
}
}
add_point( points, x0, y0, z0);
}
inline bool operator()(const segment<const PS>& s, state_type& state) const
{
/* Algorithm:
For each segment:
begin
dx = x2 - x1;
dy = y2 - y1;
sx = x2 + x1;
sy = y2 + y1;
mx = dx * sy;
my = sx * dy;
sum_mx += mx;
sum_my += my;
sum_msx += mx * sx;
sum_msy += my * sy;
end;
return POINT(0.5 * sum_msx / sum_mx, 0.5 * sum_msy / sum_my);
*/
PS diff = s.second, sum = s.second;
subtract_point(diff, s.first);
add_point(sum, s.first);
// We might create an arithmatic operation for this.
PS m;
get<0>(m) = get<0>(diff) * get<1>(sum);
get<1>(m) = get<0>(sum) * get<1>(diff);
add_point(state.sum_m, m);
multiply_point(m, sum);
add_point(state.sum_ms, m);
return true;
}
void do_ss_frame(Widget w, XtPointer client_data, XtPointer call_data)
/*
* Gte the selected set and call the routine to open up an Xbae widget
*/
{
EditPoints *ep;
int gno = cg;
int setno = GetSelectedSet(editp_set_item);
if (setno == SET_SELECT_ERROR) {
errwin("No set selected");
return;
}
if( setno == SET_SELECT_NEXT ) {
if( (setno=nextset(gno)) != -1 ) {
add_point(gno, setno, 0., 0., 0, 0, SET_XY);
add_point(gno, setno, 1, 1, 0, 0, SET_XY);
setcomment( gno, setno, "editor" );
update_set_status( gno, setno );
} else {
errwin("No set selected");
return;
}
}
if (isactive_set(gno, setno)) {
if (((ep = (EditPoints *) geteditpoints(gno, setno)) != NULL)
&& (ep->top != NULL)) {
XtRaise(ep->top);
} else {
ep = newep(gno, setno);
create_ss_frame(ep);
}
} else {
errwin("Set not active");
}
}
Line31::Line31(
const Brush* brush, const Color* stroke, const Color* fill,
Coord x1, Coord y1, Coord x2, Coord y2, Transformer* t
) : Graphic31(brush, stroke, fill, nil, false, false, 2, t) {
add_point(x1, y1);
add_point(x2, y2);
}
/*======== void generate_sphere() ==========
Inputs: struct matrix * points
double cx
double cy
double r
double step
Returns:
Generates all the points along the surface of a
sphere with center (cx, cy) and radius r
Adds these points to the matrix parameter
03/22/12 11:30:26
jdyrlandweaver
====================*/
void generate_sphere( struct matrix * points,
double cx, double cy, double r,
double step ) {
//t = θ = angle of circle generation
//p = ϕ = angle of circle rotation
double x0, y0, z0, x, y, z, t, p;
x0 = cx + r;
y0 = cy;
z0 = 0;
for ( t = step; t <= 1; t+= step ) {
for ( p = step; p <= 1; p+= step ) {
x = r * cos( 2 * M_PI * t ) + cx;
y = r * sin( 2 * M_PI * t ) * cos( 2 * M_PI * p ) + cy; //-sinp ?
z = r * sin( 2 * M_PI * t ) * sin( 2 * M_PI * p ) + 0; //-cos p?
add_point(points, x0, y0, z0);
x0 = x;
y0 = y;
z0 = z;
}
}
add_point( points, x0, y0, z0);
}
/*======== void add_edge() ==========
Inputs: struct matrix * points
int x0, int y0, int z0, int x1, int y1, int z1
Returns:
add the line connecting (x0, y0, z0) to (x1, y1, z1) to points
should use add_point
====================*/
void
add_edge (struct matrix *points,
double x0, double y0, double z0, double x1, double y1, double z1)
{
add_point (points, x0, y0, z0);
add_point (points, x1, y1, z1);
}
void Graphic31::add_curve(
Coord x, Coord y, Coord x1, Coord y1, Coord x2, Coord y2
) {
add_point(x1, y1);
add_point(x2, y2);
add_point(x, y);
}
t_point *get_point(char *bu)
{
t_var var;
char *value;
t_point *bpoints;
initvar(&var);
bpoints = malloc(sizeof(t_point) * nbpoints(bu));
while (bu[var.i])
{
if (ft_isdigit(bu[var.i]) == 0 && bu[var.i] != '\n' && bu[var.i] != '-')
var.i++;
else if (bu[var.i] == '\n')
incremvar(&var.m, &var.i, &var.j, 1);
else
{
bu = bu + var.i;
var.i = 0;
while (chartester(bu[var.i]) == 0)
incremvar(&var.k, &var.i, &var.j, 0);
value = ft_strncpy(ft_strnew(var.k), bu, var.k);
bpoints[var.l] = add_point(value, var.m, var.j);
incremvar(&var.j, &var.l, &var.k, 1);
}
}
bpoints[var.l] = add_point("-1", -1, -1);
return (bpoints);
}
/*======== void add_edge() ==========
Inputs: struct matrix * points
int x0, int y0, int z0, int x1, int y1, int z1
Returns:
add the line connecting (x0, y0, z0) to (x1, y1, z1) to points
should use add_point
====================*/
void add_edge( struct matrix * points,
double x0, double y0, double z0,
double x1, double y1, double z1) {
//printf("(%lf,%lf,%lf) to (%lf,%lf,%lf)\n",x0,y0,z0,x1,y1,z1);
add_point( points, x0, y0, z0 );
add_point( points, x1, y1, z1 );
}
static int handle_segment (const PluginLine *line, void *context, int extend_flags) {
editor_line_copy_points *copy_points = (editor_line_copy_points *)context;
RoadMapPosition from;
RoadMapPosition to;
int first;
int last;
RoadMapShapeItr itr;
int shape;
roadmap_plugin_get_line_points (line, &from, &to, &first, &last, &itr);
add_point (copy_points, &from);
if (first >= 0) {
for (shape = first; shape <= last; shape++) {
if (itr)
itr (shape, &from);
else
roadmap_shape_get_position (shape, &from);
add_point (copy_points, &from);
}
}
return 0;
}
void add_infinit_points_to_K(CHpoints *S) {
CHpoints *temp;
key key;
/* Allocate space for the Voronoi nodes and edges */
K = (Knode *) calloc(2*CHno-1,sizeof(Knode));
E = (Enode *) calloc(2*CHno-2,sizeof(Enode));
CHSplaytree=CHinit();
temp = S->next;
/* Add v(S) to K. (1) */
add_point(compute_v(S)); /* Add the point to K */
S->v = Kcount-1; /* Update the "pointer" in S
to point to v(S) in K */
CHinsert(&CHSplaytree,S);
while (temp != S) {
/* Add v(S) to K. (1) */
add_point(compute_v(temp)); /* Add the point to K */
temp->v=Kcount-1; /* Update the "pointer" in temp
to point to v(S) in K */
CHinsert(&CHSplaytree,temp);
temp=temp->next; }
}
/*======== void add_curve() ==========
Inputs: struct matrix *points
double x0
double y0
double x1
double y1
double x2
double y2
double x3
double y3
double step
int type
Returns:
Adds the curve bounded by the 4 points passsed as parameters
of type specified in type (see matrix.h for curve type constants)
to the matrix points
03/16/12 15:24:25
jdyrlandweaver
====================*/
void add_curve( struct matrix *points,
double x0, double y0,
double x1, double y1,
double x2, double y2,
double x3, double y3,
double step, int type ) {
struct matrix* coefx;
struct matrix* coefy;
if(type == HERMITE_MODE){
coefx = generate_curve_coefs(x0,x2,x1-x0,x2-x3,type);
coefy = generate_curve_coefs(y0,y2,y1-y1,y2-y3,type);
}
else if(type == BEZIER_MODE){
coefx = generate_curve_coefs(x0,x1,x2,x3,type);
coefy = generate_curve_coefs(y0,y1,y2,y3,type);
}
double t = 0;
double x,y;
while(t<1.0){
x = t*(t*(coefx->m[0][0]*t+coefx->m[1][0])+coefx->m[2][0])+coefx->m[3][0];
y = t*(t*(coefy->m[0][0]*t+coefy->m[1][0])+coefy->m[2][0])+coefy->m[3][0];
add_point(points,x,y,0);
t += 1.0/step;
x = t*(t*(coefx->m[0][0]*t+coefx->m[1][0])+coefx->m[2][0])+coefx->m[3][0];
y = t*(t*(coefy->m[0][0]*t+coefy->m[1][0])+coefy->m[2][0])+coefy->m[3][0];
add_point(points,x,y,0);
}
}
/*======== void add_edge() ==========
Inputs: struct matrix * points
int x0, int y0, int z0, int x1, int y1, int z1
Returns:
add the line connecting (x0, y0, z0) to (x1, y1, z1) to points
should use add_point
====================*/
void add_edge( struct matrix * points,
int x0, int y0, int z0,
int x1, int y1, int z1) {
printf("WHERE ARE U SEG FAULT ft. add_edge \n");
add_point(points, x0, y0, z0);
add_point(points, x1, y1, z1);
printf("WHERE ARE U SEG FAULT ft. add_edge pt. 2\n");
}
/*======== void add_polygon() ==========
Inputs: struct matrix *surfaces
double x0
double y0
double z0
double x1
double y1
double z1
double x2
double y2
double z2
Returns:
Adds the vertices (x0, y0, z0), (x1, y1, z1)
and (x2, y2, z2) to the polygon matrix. They
define a single triangle surface.
04/16/13 13:05:59
jdyrlandweaver
====================*/
void add_polygon( struct matrix *polygons,
double x0, double y0, double z0,
double x1, double y1, double z1,
double x2, double y2, double z2 ) {
add_point(polygons, x0, y0, z0);
add_point(polygons, x1, y1, z1);
add_point(polygons, x2, y2, z2);
}
void MeshWorld::add_triangle(Point p1, Point p2, Point p3)
{
int p1_index = add_point(p1);
int p2_index = add_point(p2);
int p3_index = add_point(p3);
Triangle *t = new Triangle(p1_index, p2_index, p3_index);
polygons.push_back(t);
}
bool LocalAnt::random_search_neighborhood_v2()
{
int next[8] = { 0,0 };
int total_next = 0;
pos temp;
for (int i = 0; i < 8; i++) {
temp.set(m_pos.m_x + m_gp.next_step[i][0], m_pos.m_y + m_gp.next_step[i][1]);
if (m_gp.judge(temp) && !mvv_visited[temp.m_x][temp.m_y] && inInNeighborhood_v2(temp))
{
total_next++;
next[i] = 1;
}
}
if (total_next == 0) {
return false;
}
else {
double randNum(Global::msp_global->getDoubleRand());
randNum *= total_next;
randNum = int(randNum);
total_next = -1;
int temp_next;
for (int i = 0; i < 8; i++) {
if (next[i])
{
total_next++;
if (total_next >= randNum)
{
temp_next = i;
break;
}
}
}
add_point(temp_next);
if (m_gp.judgeFood(m_pos))
{
m_state = successfully_return_s;
reset_from_food();
//reset();
return true;
}
if (m_gp.judgeNearFood(m_pos))
{
add_point(m_gp.m_food);
m_state = successfully_return_s;
reset_from_food();
return true;
}
return true;
}
}
Polygon31::Polygon31 (
const Brush* brush, const Color* stroke, const Color* fill,
Coord* x, Coord* y, int n, Transformer* t
) : Graphic31(brush, stroke, fill, nil, true, false, n, t) {
add_point(x[0], y[0]);
for (int i = 1; i < n; ++i) {
add_point(x[i], y[i]);
}
}
Rectangle31::Rectangle31 (
const Brush* brush, const Color* stroke, const Color* fill,
Coord l, Coord b, Coord r, Coord t, Transformer* tx
) : Graphic31(brush, stroke, fill, nil, true, false, 4, tx) {
add_point(r, b);
add_point(r, t);
add_point(l, t);
add_point(l, b);
}
inline bool projected_to_surface(Point3d const& origin, Point3d const& direction, Point3d & result1, Point3d & result2, Spheroid const& spheroid)
{
typedef typename coordinate_type<Point3d>::type coord_t;
coord_t const c0 = 0;
coord_t const c1 = 1;
coord_t const c2 = 2;
coord_t const c4 = 4;
// calculate the point of intersection of a ray and spheroid's surface
//(x*x+y*y)/(a*a) + z*z/(b*b) = 1
// x = o.x + d.x * t
// y = o.y + d.y * t
// z = o.z + d.z * t
coord_t const ox = get<0>(origin);
coord_t const oy = get<1>(origin);
coord_t const oz = get<2>(origin);
coord_t const dx = get<0>(direction);
coord_t const dy = get<1>(direction);
coord_t const dz = get<2>(direction);
//coord_t const a_sqr = math::sqr(get_radius<0>(spheroid));
//coord_t const b_sqr = math::sqr(get_radius<2>(spheroid));
// "unit" spheroid, a = 1
coord_t const a_sqr = 1;
coord_t const b_sqr = math::sqr(formula::unit_spheroid_b<coord_t>(spheroid));
coord_t const param_a = (dx*dx + dy*dy) / a_sqr + dz*dz / b_sqr;
coord_t const param_b = c2 * ((ox*dx + oy*dy) / a_sqr + oz*dz / b_sqr);
coord_t const param_c = (ox*ox + oy*oy) / a_sqr + oz*oz / b_sqr - c1;
coord_t const delta = math::sqr(param_b) - c4 * param_a*param_c;
// equals() ?
if (delta < c0 || param_a == 0)
{
return false;
}
// result = origin + direction * t
coord_t const sqrt_delta = math::sqrt(delta);
coord_t const two_a = c2 * param_a;
coord_t const t1 = (-param_b + sqrt_delta) / two_a;
result1 = direction;
multiply_value(result1, t1);
add_point(result1, origin);
coord_t const t2 = (-param_b - sqrt_delta) / two_a;
result2 = direction;
multiply_value(result2, t2);
add_point(result2, origin);
return true;
}
ABCX() {
add_point(A, Vector3(0, 0, 0));
add_point(B, Vector3(1, 0, 0));
add_point(C, Vector3(0, 1, 0));
add_point(X, Vector3(0, 0, 1));
connect_points(A, B);
connect_points(A, C);
connect_points(B, C);
connect_points(X, A);
}
void move_pac_man(t_pac_man *pac_man, t_map map, t_tile tile[N_TILE])
{
if (ABS(pac_man->sub_pos.x) == (CASE_SIZE / 2)
|| ABS(pac_man->sub_pos.y) == (CASE_SIZE / 2))
change_direction___(pac_man, map, tile);
pac_man->sub_pos = add_point(pac_man->sub_pos, g_move[pac_man->direction]);
pac_man->abs_pos = add_point(pac_man->abs_pos, g_move[pac_man->direction]);
pac_man->sub_pos = add_point(pac_man->sub_pos, g_move[pac_man->direction]);
move_case_axe(&pac_man->sub_pos.x, &pac_man->map_pos.x);
move_case_axe(&pac_man->sub_pos.y, &pac_man->map_pos.y);
}
bool LocalAnt::selectNextPointGreedy() {
//bool isfind = 0;
int next(-1);
double dis (m_gp.m_inf);
// double temp;
pos next_pos;
for (int i = 0; i < 8; i++) {
//if(!mvv_visited[][])
next_pos.set(m_pos.m_x + m_gp.next_step[i][0], m_pos.m_y + m_gp.next_step[i][1]);
if (m_gp.judge(next_pos) && !mvv_visited[next_pos.m_x][next_pos.m_y]) {
if (mvv_distance_from_food[next_pos.m_x][next_pos.m_y] < dis) {
next = i;
dis = mvv_distance_from_food[next_pos.m_x][next_pos.m_y];
}
}
}
if (dis == m_gp.m_inf) {
// reset_from_food();
reset_start_from_home();
m_state = second_search;
return false;
}
else {
add_point(next);
if (m_gp.judgeFood(m_pos))
{
m_state = successfully_return_s;
reset_from_food();
//reset();
return true;
}
if (m_gp.judgeNearFood(m_pos))
{
add_point(m_gp.m_food);
m_state = successfully_return_s;
reset_from_food();
return true;
}
}
return false;
}
/*======== void add_circle() ==========
Inputs: struct matrix * points
double cx
double cy
double y
double step
Returns:
rcos(2πt) + cx
y = rcos(2πt) + cy
03/16/12 19:53:52
jdyrlandweaver
====================*/
void add_circle( struct matrix * points,
double cx, double cy,
double r, double step ) {
double t, x, y, x1, y1;
x = x1 = cx + r;
y = y1 = cy;
for (t = 0; t <= 1; t += step) {
add_point(points, x, y, 0);
x = r * cos(2 * M_PI * t) + cx;
y = r * sin(2 * M_PI * t) + cy;
add_point(points, x, y, 0);
}
add_edge(points, x, y, 0, x1, y1, 0);
}
void AddPointDialog::process_input()
{
double x = x_text_box->text().toDouble();
double y = y_text_box->text().toDouble();
if(has_name_box->isChecked())
{
std::string name = point_name_tb->text().toStdString();
emit add_point(x,y,name);
}
else
{
emit add_point(x,y);
}
close();
}
v3dmc_object load_object(GLchar *filename){
FILE *file;
GLint i,npoints,nlines,ntriangles,nquads;
v3dmc_object obj = object();
v3dmc_point p;
v3dmc_line l;
v3dmc_triangle t;
v3dmc_quad q;
file = fopen(filename,"r");
if(file!=NULL){
fread(&npoints,sizeof(int),1,file);
fread(&nlines,sizeof(int),1,file);
fread(&ntriangles,sizeof(int),1,file);
fread(&nquads,sizeof(int),1,file);
for(i=0;i<npoints;i++){
read_point(file,&p);
add_point(&obj,p);
}
for(i=0;i<nlines;i++){
fread(&l,sizeof(v3dmc_line),1,file);
add_line(&obj,l);
}
for(i=0;i<ntriangles;i++){
fread(&t,sizeof(v3dmc_triangle),1,file);
add_triangle(&obj,t);
}
for(i=0;i<nquads;i++){
fread(&q,sizeof(v3dmc_quad),1,file);
add_quad(&obj,q);
}
fclose(file);
}
return obj;
}
/*======== void generate_torus() ==========
Inputs: struct matrix * points
double cx
double cy
double r
double step
Returns:
Generates all the points along the surface of a
tarus with center (cx, cy) and radii r1 and r2
Adds these points to the matrix parameter
03/22/12 11:30:26
jdyrlandweaver
====================*/
void
generate_torus (struct matrix *points,
double cx, double cy, double r1, double r2, double step)
{
double x, y, z, circle, rotation;
double rotStart = step * 0;
double rotStop = 1;
for (rotation = rotStart; rotation <= rotStop; rotation += step)
{
for (circle = 0; circle <= 1; circle += step)
{
x = cos (2 * M_PI * rotation) *
(r1 * cos (2 * M_PI * circle) + r2) + cx;
y = r1 * sin (2 * M_PI * circle) + cy;
z = sin (2 * M_PI * rotation) * (r1 * cos (2 * M_PI * circle) + r2);
add_point (points, x, y, z);
}
}
}
/* read line coordinates */
void read_coor(FILE * fp, SYMBEL * e)
{
char buf[501];
double x, y;
G_debug(5, " read_coor()");
while (G_getl2(buf, 500, fp) != 0) {
G_chop(buf);
/* skip empty and comment lines */
if ((buf[0] == '#') || (buf[0] == '\0'))
continue;
get_key_data(buf);
if (strcmp(key, "END") == 0) {
G_debug(5, " LINE END");
return;
}
if (sscanf(buf, "%lf %lf", &x, &y) != 2) {
G_warning(_("Cannot read symbol line coordinates: %s"), buf);
return;
}
G_debug(5, " x = %f y = %f", x, y);
add_point(e, x, y);
}
}
/*======== void generate_torus() ==========
Inputs: struct matrix * points
double cx
double cy
double r
double step
Returns:
Generates all the points along the surface of a
tarus with center (cx, cy) and radii r1 and r2
Adds these points to the matrix parameter
03/22/12 11:30:26
jdyrlandweaver
====================*/
void generate_torus( struct matrix * points,
double cx, double cy, double cz, double r1, double r2,
int step ) {
double x, y, z, circ, rot;
int circle, rotation;
double rotStart = step * 0;
double rotStop = MAX_STEPS;
double circStart = step * 0;
double circStop = MAX_STEPS;
for ( rotation = rotStart; rotation < rotStop; rotation += step ) {
rot = (double)rotation / MAX_STEPS;
for ( circle = circStart; circle < circStop; circle+= step ) {
circ = (double)circle / MAX_STEPS;
x = cos( 2 * M_PI * rot ) *
( r1 * cos( 2 * M_PI * circ ) + r2 ) + cx;
y = r1 * sin( 2 * M_PI * circ ) + cy;
z = sin( 2 * M_PI * rot ) *
( r1 * cos( 2 * M_PI * circ ) + r2 ) + cz;
add_point( points, x, y, z );
}
}
}
void
histogram_t::compile (const dataset_t &d)
{
for (size_t s = 0; s < d.size (); s++) {
add_point (d[s]);
}
}
