int lineClip (osuVertex &v0, osuVertex &v1,double a, double b,double c,double d0, double d1)
{
osuVertex newv0, newv1;
int in0,in1; /* are v0 or v1 in the proper half-space */
int status = 1;
in0 = (a * v0.x + b * v0.y + c * v0.z + d0 > 0);
in1 = (a * v1.x + b * v1.y + c * v1.z + d1 > 0);
if (in0 && in1) {
//do nothing, I'll return v0 and v1
}
else if (!in0 && in1) {
create_vertex(v0, v1, newv0, a, b, c,d0);
vertex_copy(v0, newv0);
}
else if (in0 && !in1) {
create_vertex(v0, v1, newv1, a, b, c,d1);
vertex_copy(v1, newv1);
}
else {
/* both are not in, so we add no vertices to the clipped line*/
status = 0;
}
in0 = in1;
return(status);
}
int simplex_collapsed(const simplex_t *s)
{
static vertex_t *a, *b;
int i, j;
if (!a || !b || a->id != N) {
free(a);
free(b);
a = vertex_alloc();
b = vertex_alloc();
if (!a || !b)
return -1;
}
vertex_copy(a, s->vertex[0]);
vertex_regrid(a);
a->id = N;
for (i = 1; i < s->len; ++i) {
vertex_copy(b, s->vertex[i]);
vertex_regrid(b);
for (j = 0; j < N; ++j) {
if (a->term[j] != b->term[j])
return 0;
}
}
return 1;
}
int vertex_center(vertex_t *v)
{
int i;
vertex_copy(v, vmin);
for (i = 0; i < N; ++i)
v->term[i] += (vmax->term[i] - vmin->term[i]) / 2;
hperf_reset(v->perf);
return 0;
}
void simplex_transform(const simplex_t *src, const vertex_t *wrt,
double coefficient, simplex_t *result)
{
int i;
for (i = 0; i < src->len; ++i) {
if (src->vertex[i] == wrt) {
vertex_copy(result->vertex[i], src->vertex[i]);
continue;
}
vertex_transform(src->vertex[i], wrt, coefficient, result->vertex[i]);
}
}
int pro_next_simplex(simplex_t *output)
{
int i;
switch (state) {
case SIMPLEX_STATE_INIT:
/* Bootstrap the process by testing the reference simplex. */
simplex_copy(output, base);
break;
case SIMPLEX_STATE_REFLECT:
/* Reflect all original simplex vertices around the best known
* vertex thus far. */
simplex_transform(base, base->vertex[best_base], -reflect, output);
break;
case SIMPLEX_STATE_EXPAND_ONE:
/* Next simplex should have one vertex extending the best.
* And the rest should be copies of the best known vertex.
*/
vertex_transform(test->vertex[best_test], base->vertex[best_base],
expand, output->vertex[0]);
for (i = 1; i < simplex_size; ++i)
vertex_copy(output->vertex[i], base->vertex[best_base]);
break;
case SIMPLEX_STATE_EXPAND_ALL:
/* Expand all original simplex vertices away from the best
* known vertex thus far. */
simplex_transform(base, base->vertex[best_base], expand, output);
break;
case SIMPLEX_STATE_SHRINK:
/* Shrink all original simplex vertices towards the best
* known vertex thus far. */
simplex_transform(base, base->vertex[best_base], shrink, output);
break;
case SIMPLEX_STATE_CONVERGED:
/* Simplex has converged. Nothing to do.
* In the future, we may consider new search at this point. */
break;
default:
return -1;
}
return 0;
}
int simplex_copy(simplex_t *dst, const simplex_t *src)
{
int i;
if (dst == src)
return 0;
if (dst->len != src->len)
return -1;
for (i = 0; i < src->len; ++i)
vertex_copy(dst->vertex[i], src->vertex[i]);
return 0;
}
void generate_random_graph1
(MutableGraph& g,
typename graph_traits<MutableGraph>::vertices_size_type V,
typename graph_traits<MutableGraph>::vertices_size_type E,
RandNumGen& gen,
bool allow_parallel = true,
bool self_edges = false)
{
typedef graph_traits<MutableGraph> Traits;
typedef typename Traits::vertices_size_type v_size_t;
typedef typename Traits::edges_size_type e_size_t;
typedef typename Traits::vertex_descriptor vertex_descriptor;
// When parallel edges are not allowed, we create a new graph which
// does not allow parallel edges, construct it and copy back.
// This is not efficient if 'g' already disallow parallel edges,
// but that's task for later.
if (!allow_parallel) {
typedef typename boost::graph_traits<MutableGraph>::directed_category dir;
typedef typename mpl::if_<is_convertible<dir, directed_tag>,
directedS, undirectedS>::type select;
adjacency_list<setS, vecS, select> g2;
generate_random_graph1(g2, V, E, gen, true, self_edges);
copy_graph(g2, g, vertex_copy(detail::dummy_property_copier()).
edge_copy(detail::dummy_property_copier()));
} else {
for (v_size_t i = 0; i < V; ++i)
add_vertex(g);
for (e_size_t j = 0; j < E; ++j) {
vertex_descriptor a = random_vertex(g, gen), b;
do {
b = random_vertex(g, gen);
} while (self_edges == false && a == b);
add_edge(a, b, g);
}
}
}
