void Controller::draw_separators() const
{
logger.info(mmlt_msg("Drawing Separators..."));
for(SegmentIndex index = 0; index < intersection_algorithm_.shortest_noncrossing_segment_; ++index)
{
SVGPainter painter(file_prefix_, QString("separators_%1.svg").arg(index), bounding_box_);
//draw_segments(painter);
painter.setPenColor(QColor(255, 0, 0));
const Intersections& intersections = intersection_graph_[index];
std::vector<SegmentIndex> separators;
intersections.find_separators(index, segments_, separators);
for(const SegmentIndex& separator_index : separators)
{
const Segment& separator= segments_[separator_index];
separator.draw(painter);
}
painter.setPenColor(QColor(0, 255, 0));
const Segment& segment = segments_[index];
segment.draw(painter);
draw_points(painter);
}
}
int draw_particles(void)
{
static Vec pointv[512];
static size_t pointc = ARRLEN(pointv, Vec);
double z = zoom();
particle_t* p = particles;
int i = 0;
size_t count = HASH_COUNT(particles);
while(i < count) {
for(; p != NULL && i < pointc; p = p->hh.next, i++) {
cpVect pos = cpBodyGetPos(p->body);
if(fabs(pos.x) <= z / 2 && fabs(pos.y) <= z / 2) {
// rough check if position is inside screen borders
// TODO: possibly make it separate function
pointv[i] = cpv2vec(pos);
}
}
if(draw_points(pointv, i % pointc)) {
return -1;
}
}
return 0;
}
/**
* @brief Renders everything; called once on startup
* and then to animate hull algorithm steps.
*/
void ConvexHullApp::OnRender()
{
SDL_FillRect(surf, NULL, SDL_MapRGB(surf->format, 255, 255, 255));
draw_points();
draw_hull();
SDL_Flip(surf);
}
void Scene_polyhedron_shortest_path_item::draw(Viewer_interface* viewer) const
{
if (supportsRenderingMode(renderingMode()))
{
draw_points(viewer);
}
}
void Scene_polyhedron_selection_item::draw(Viewer_interface* viewer) const
{
if(!are_buffers_filled)
initialize_buffers(viewer);
draw_points(viewer);
GLfloat offset_factor;
GLfloat offset_units;
viewer->glGetFloatv( GL_POLYGON_OFFSET_FACTOR, &offset_factor);
viewer->glGetFloatv(GL_POLYGON_OFFSET_UNITS, &offset_units);
glPolygonOffset(-1.f, 1.f);
vaos[0]->bind();
program = getShaderProgram(PROGRAM_WITH_LIGHT);
attrib_buffers(viewer,PROGRAM_WITH_LIGHT);
program->bind();
program->setAttributeValue("colors",facet_color);
viewer->glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(nb_facets/3));
program->release();
vaos[0]->release();
glPolygonOffset(offset_factor, offset_units);
draw_edges(viewer);
}
void Scene::draw()
{
if(m_view_plane)
::glEnable(GL_DEPTH_TEST);
else
::glDisable(GL_DEPTH_TEST);
if(m_view_polyhedron)
draw_polyhedron();
if(m_view_points)
draw_points();
if(m_view_segments)
draw_segments();
if (m_view_plane)
{
switch( m_cut_plane )
{
case UNSIGNED_EDGES:
case UNSIGNED_FACETS:
draw_distance_function(m_thermal_ramp, m_thermal_ramp);
break;
case SIGNED_FACETS:
draw_distance_function(m_red_ramp, m_blue_ramp);
break;
case CUT_SEGMENTS:
draw_cut_segment_plane();
break;
case NONE: // do nothing
break;
}
}
}
void MGCommandDrawer::draw_points_lines(
const MGColor& pcolor, //color of points(boundary)
const MGColor& lcolor, //color of line.
const std::vector<MGPosition>& ipos
)const{
draw_lines(lcolor,ipos);
draw_points(pcolor,ipos);
}
/**
* @brief Renders everything; called once on startup
* and then to animate clicks and line algorithm calls.
*/
void LineApp::OnRender()
{
SDL_FillRect(surf, NULL, SDL_MapRGB(surf->format, 255, 255, 255));
draw_points();
draw_line_points();
SDL_Flip(surf);
}
void breakpoints_paint(t_breakpoints *x, t_object *view)
{
t_rect rect;
ebox_get_rect_for_view((t_ebox *)x, &rect);
x->f_size.x = rect.width;
x->f_size.y = rect.height;
draw_text(x, view, &rect);
draw_points(x, view, &rect);
}
void disp(void)
{
glClear(GL_COLOR_BUFFER_BIT);
draw_points();
if(show_linear) draw_linear();
if(show_catmull_rom) draw_catmull_rom();
if(show_bezier) draw_bezier();
glutSwapBuffers();
}
//drawing all about (current) distribution
void MainWindow::draw_distribution(const int activeDistributionNumber, QGraphicsScene * scene)
{
if (ui.checkBoxSelection->isChecked())
draw_points(activeDistributionNumber, scene);
if (ui.checkBoxMiddle->isChecked())
draw_middle_point(activeDistributionNumber, scene);
if (ui.checkBoxIsolines->isChecked())
draw_isolines(activeDistributionNumber, scene);
}
void particles_render::draw_heat(const explosion &e) const
{
const float life_time = 5.0f;
clear_points();
auto atc = tc(1920, 1664, 128, 128);
auto nt = e.m_time / life_time;
auto t = nya_math::min(e.m_time, 1.0f) + nt * 0.1f;
auto r = e.m_radius * t * 3.0f;
add_point(e.m_pos, r, atc, false, atc, false, color(1.0f, 1.0f, 1.0f, 1.0f) * 0.2f);
draw_points();
}
int main(int argc, char **argv)
{
t_cloud data;
init_struct(&data);
if (argc != 2)
error_fdf("fdf");
parser(argv, &data);
draw_points(data.start_node, &data);
mlx_hook(data.win, 2, (1L << 0), distrib_key, &data);
mlx_loop(data.mlx);
return (0);
}
void Controller::draw_triangulation() const
{
logger.debug( mmlt_msg( "Drawing triangulation..." ) );
SVGPainter painter(file_prefix_, "solution.svg", bounding_box_);
//draw_segments(painter);
painter.setPenColor(QColor(255, 0, 0));
triangulation_.draw(painter);
draw_points(painter);
}
void main(void)
{
int gd = DETECT, gm;
double points[6][2] = {-3, 2, -2, -1.5, -1, 0, 0, 0, 1, 1, 2, -1.5};
node *poly;
if ((poly = lagrange(points, 6)) != NULL)
print_polynomial(poly, "poly = ");
else printf("Impossible !!!!");
getch();
initgraph(&gd, &gm, "c:\\tcpp\\bgi");
draw_points(points, 6, 0, 0, 100);
draw(poly, 0, 0, -5, 5, 100, 0.05);
getch();
closegraph();
}
int main(int argc, char const **argv)
{
init_env(argc, argv);
omp_set_num_threads(num_thread);
high_resolution_clock::time_point s;
Gmm = G * mass * mass;
for (int i = 0; i < iters; ++i) {
if (gui) draw_points(0);
s = high_resolution_clock::now();
#pragma omp parallel for schedule(dynamic, 50)
for (int j = 0; j < num_body; ++j) move_nth_body(j);
Body* t = new_bodies; new_bodies = bodies; bodies = t;
total_time += timeit(s);
}
INFO("Run in " << total_time.count() / 1000 << " us");
return 0;
}
void Controller::draw_bounds() const
{
logger.info(mmlt_msg("Drawing bounds..."));
SVGPainter painter(file_prefix_, QString("bounds_%1.svg").arg(stats_.iteration), bounding_box_);
draw_segments(painter);
painter.setPenColor(QColor(255, 255, 0));
segments_.draw_range(painter, stats_.lower_bound(), stats_.upper_bound());
painter.setPenColor(QColor(0, 255, 0));
segments_[stats_.lower_bound()].draw(painter);
painter.setPenColor(QColor(255, 0, 0));
segments_[stats_.upper_bound()].draw(painter);
draw_points(painter);
}
void Controller::draw_sat_solution() const
{
logger.debug( mmlt_msg( "Drawing SAT solution..." ) );
SVGPainter painter(file_prefix_, QString("sat_%1.svg").arg(stats_.iteration), bounding_box_);
//draw_segments(painter);
painter.setPenColor(QColor(255, 255, 0));
segments_.draw_range(painter, stats_.lower_bound(), stats_.upper_bound());
painter.setPenColor(QColor(255, 0, 0));
last_sat_solution_.draw_short_segments(painter, stats_.upper_bound(), segments_);
painter.setPenColor(QColor(0, 255, 0));
last_sat_solution_.draw_separators(painter, stats_.upper_bound(), segments_);
draw_points(painter);
}
/**
* Draw the list of coordinates currently in the database
*
* @author HP Truong, Jacob Barnett
*
* @param void
* @return void
*/
void draw_from_db(void) {
LCD_Clear(LCD_COLOR_WHITE);
LCD_SetTextColor(LCD_COLOR_RED);
memcpy ( (void *)(LCD_FRAME_BUFFER + BUFFER_OFFSET), (void *) ((uint8_t*) (&background)), sizeof(background));
uint8_t len = coordinate_db_get_len();
if (len == 0) {
return;
}
static coordinate next_coord;
for (uint8_t i = 0; i < len; i++) {
coordinate_db_get_entry(i, &next_coord);
xs[i] = next_coord.x;
ys[i] = next_coord.y;
}
draw_points(1, 1, xs, ys, len);
}
static void display_func ( void )
{
fps_time += timer.GetElapsedTime();
rot_time += timer.GetElapsedTime();
timer.Reset();
frames++;
if(fps_time >= 10.0 && rate)
{
cout<<"Framerate:"<<(frames/fps_time)<<endl;
frames = 0;
fps_time = 0;
}
pre_display ();
if ( dvel==0 ) draw_velocity ();
else if ( dvel==1 ) draw_density ();
else if ( dvel==2 ) draw_points ();
else if ( dvel==3 ) draw_particles ();
post_display ();
}
int distrib_key(int key_value, t_cloud *data)
{
if (key_value == 65307 || key_value == 53)
exit(0);
/* else if (key_value == 69 || key_value == 65451)
data->zoom += 0.1;
else if (key_value == 78 || key_value == 65453)
data->zoom -= 0.1;*/
else if (key_value == 69 || key_value == 65451)
data->depth += 0.1;
else if (key_value == 78 || key_value == 65453)
data->depth -= 0.1;
else if (key_value == 125)
data->e_y += 15;
else if (key_value == 126)
data->e_y -= 15;
else if (key_value == 123)
data->e_x += 15;
else if (key_value == 124)
data->e_x -= 15;
else if (key_value == 258)
data->e_z += 1;
else if (key_value == 269)
data->e_z -= 1;
else if (key_value == 116)
data->ang_x += 1;
else if (key_value == 121)
data->ang_x -= 1;
else if (key_value == 86)
data->ang_y += 1;
else if (key_value == 88)
data->ang_y -= 1;
printf("key =%d,\n", key_value);
mlx_clear_window(data->mlx, data->win);
set_3d_pos(data->start_node, data);
draw_points(data->start_node, data);
return (0);
}
void Controller::draw_intersections() const
{
logger.info( mmlt_msg( "Drawing intersections..." ) );
SegmentIndex segment_index = 0;
for(const Intersections& intersections : intersection_graph_)
{
SVGPainter painter(file_prefix_, QString("%1_intersections.svg").arg(segment_index, 5, 10, QChar('0')), bounding_box_);
draw_segments(painter);
painter.setPenColor(QColor(0, 255, 0));
segments_[segment_index].draw(painter);
painter.setPenColor(QColor(255, 0, 0));
intersections.draw(painter, segments_);
draw_points(painter);
++segment_index;
}
}
int main(int argc, char **argv)
{
int fd;
t_cloud data;
t_node nodes;
init_struct(&data);
if (argc <= 1 || argc >= 3)
return (argc <= 1 ? error("Too few arguments")
: error("Too many arguments"));
if (argc != 2)
return (error("Error parameters"));
if ((fd = open(argv[1], O_RDONLY)) == -1)
return (error("Error open file"));
if (!parser(fd, &data, &nodes))
return (error("Parsing Error"));
close(fd);
draw_points(data.start_node, &data);
mlx_hook(data.win, 2, (1L << 0), distrib_key, &data);
// mlx_key_hook(data.win, distrib_key, &data);
mlx_loop(data.mlx);
return (0);
}
void particles_render::draw(const fire_trail &t) const
{
clear_points();
for (size_t fi = 0; fi < t.m_count; ++fi)
{
const int i = (fi + t.m_offset) % t.max_count;
const int tc_w_count = 16;
//const int tc_h_count = 2;
const int tc_idx = t.m_tci[i];//(tc_w_count * tc_h_count + 1) * nya_math::min(t.m_time / 5.0f, 1.0f);
bool fire = fi + 7 >= t.m_count;
color c = color(1.0f, 1.0f, 1.0f, 0.1 + 0.5f * fi / t.max_count);
if (fire)
c.xyz() *= hdr_coeff;
add_point(t.m_pos[i].xyz(), t.m_pos[i].w, tc((tc_idx % tc_w_count) * 128, (fire ? 0 : 128) + (tc_idx / tc_w_count) * 128, 128, 128), !fire,
tc(640 + t.m_tcia[i], 1280 + 128, 128, 128), true, c, nya_math::vec2(), t.m_rot[i]);
}
draw_points();
}
void sdl_visualize_clusters(point *points, int numpoints, int *cluster_centersx, int *cluster_centersy, int clusters)
{
SDL_Init(SDL_INIT_VIDEO);
SDL_WM_SetCaption("Cluster Visualization", "SDL Test");
screen = SDL_SetVideoMode(WINW, WINH, 0, 0);
SDL_Rect rect = {0, 0, WINW, WINH};
SDL_FillRect(screen, &rect, WHITE);
draw_points(points, numpoints, cluster_centersx, cluster_centersy, clusters);
debug("Entering input loop...");
SDL_Event event;
bool exit = false;
while (!exit)
{
if (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
exit = 1;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym)
{
case SDLK_UP:
up = true;
break;
case SDLK_DOWN:
down = true;
break;
case SDLK_RIGHT:
right = true;
break;
case SDLK_LEFT:
left = true;
break;
case SDLK_ESCAPE:
case SDLK_q:
exit = 1;
break;
}
break;
case SDL_KEYUP:
switch (event.key.keysym.sym)
{
case SDLK_UP:
up = false;
break;
case SDLK_DOWN:
down = false;
break;
case SDLK_RIGHT:
right = false;
break;
case SDLK_LEFT:
left = false;
break;
case SDLK_ESCAPE:
case SDLK_q:
exit = 1;
break;
}
break;
}
}
if(up == true)
adjustOffset(UP);
if(down == true)
adjustOffset(DOWN);
if(left == true)
adjustOffset(LEFT);
if(right == true)
adjustOffset(RIGHT);
if(up == true || down == true || left == true || right == true)
{
draw_points(points, numpoints, cluster_centersx, cluster_centersy, clusters);
}
SDL_UpdateRect(screen, 0, 0, 0, 0);
}
SDL_Quit();
}
/* This illustrates how to use SIFT3D within a function, and free all memory
* afterwards. */
int demo(void) {
Image im, draw;
Mat_rm keys;
SIFT3D sift3d;
Keypoint_store kp;
SIFT3D_Descriptor_store desc;
// Initialize the intermediates
init_Keypoint_store(&kp);
init_SIFT3D_Descriptor_store(&desc);
init_im(&im);
init_im(&draw);
if (init_Mat_rm(&keys, 0, 0, DOUBLE, SIFT3D_FALSE))
return 1;
if (init_SIFT3D(&sift3d)) {
cleanup_Mat_rm(&keys);
return 1;
}
// Read the image
if (im_read(im_path, &im))
goto demo_quit;
// Detect keypoints
if (SIFT3D_detect_keypoints(&sift3d, &im, &kp))
goto demo_quit;
// Write the keypoints to a file
if (write_Keypoint_store(keys_path, &kp))
goto demo_quit;
printf("Keypoints written to %s. \n", keys_path);
// Extract descriptors
if (SIFT3D_extract_descriptors(&sift3d, &kp, &desc))
goto demo_quit;
// Write the descriptors to a file
if (write_SIFT3D_Descriptor_store(desc_path, &desc))
goto demo_quit;
printf("Descriptors written to %s. \n", desc_path);
// Convert the keypoints to a matrix
if (Keypoint_store_to_Mat_rm(&kp, &keys))
goto demo_quit;
// Draw the keypoints
if (draw_points(&keys, im.dims, 1, &draw))
goto demo_quit;
// Write the drawn keypoints to a file
if (im_write(draw_path, &draw))
goto demo_quit;
printf("Keypoints drawn in %s. \n", draw_path);
// Clean up
im_free(&im);
im_free(&draw);
cleanup_Mat_rm(&keys);
cleanup_SIFT3D(&sift3d);
cleanup_Keypoint_store(&kp);
cleanup_SIFT3D_Descriptor_store(&desc);
return 0;
demo_quit:
// Clean up and return an error
im_free(&im);
im_free(&draw);
cleanup_Mat_rm(&keys);
cleanup_SIFT3D(&sift3d);
cleanup_Keypoint_store(&kp);
cleanup_SIFT3D_Descriptor_store(&desc);
return 1;
}
void conic(INT q, INT *six_coeffs, INT xmax, INT ymax, INT f_do_stabilizer, INT verbose_level)
{
const BYTE *override_poly = NULL;
finite_field F;
projective_space *P;
action *A;
INT n = 3;
//INT f_with_group = TRUE;
INT v[3];
//INT w[3];
//F.init(q), verbose_level - 2);
F.init_override_polynomial(q, override_poly, verbose_level);
P = new projective_space;
cout << "before P->init" << endl;
P->init(n - 1, &F,
FALSE /* f_init_incidence_structure */,
verbose_level/*MINIMUM(2, verbose_level)*/);
cout << "after P->init" << endl;
A = new action;
A->init_general_linear_group(n, &F, FALSE /* f_semilinear */, TRUE /* f_basis */, verbose_level - 2);
INT variety[100];
INT variety_size = 0;
INT a, i, j, h;
for (i = 0; i < P->N_points; i++) {
P->unrank_point(v, i);
a = F.evaluate_conic_form(six_coeffs, v);
cout << i << " : ";
INT_vec_print(cout, v, 3);
cout << " : " << a << endl;
if (a == 0) {
variety[variety_size++] = i;
}
}
cout << "the size of the variety is " << variety_size << endl;
cout << "the variety is:" << endl;
INT_vec_print(cout, variety, variety_size);
cout << endl;
for (i = 0; i < variety_size; i++) {
P->unrank_point(v, variety[i]);
a = F.evaluate_conic_form(six_coeffs, v);
cout << i << " : ";
INT_vec_print(cout, v, 3);
cout << " : " << a << endl;
}
#if 0
INT pts[] = {2, 22, 6, 18, 10};
find_collinear_triple(P, pts, 5);
INT five_pts[] = {3, 6, 7, 28, 30};
#endif
//INT six_coeffs[6];
INT five_pts[5];
five_pts[0] = variety[0];
five_pts[1] = variety[1];
five_pts[2] = variety[2];
five_pts[3] = variety[3];
five_pts[4] = variety[4];
P->determine_conic_in_plane(five_pts, 5, six_coeffs, verbose_level);
INT points[1000];
INT tangents[1000];
INT *exterior_points;
INT *secants;
INT nb_secants, nb_exterior_points;
INT nb_points;
//INT v[3];
P->conic_points(five_pts, six_coeffs, points, nb_points, verbose_level);
cout << "the " << nb_points << " conic points are: ";
INT_vec_print(cout, points, nb_points);
cout << endl;
for (i = 0; i < nb_points; i++) {
P->unrank_point(v, points[i]);
cout << i << " : " << points[i] << " : ";
INT_vec_print(cout, v, 3);
cout << endl;
}
strong_generators *Aut_gens;
if (f_do_stabilizer) {
// computing stabilizer:
cout << "computing stabilizer" << endl;
set_stabilizer_compute STAB;
sims *Stab;
INT nb_backtrack_nodes;
cout << "computing stabilizer of conic:" << endl;
STAB.init(A, variety, variety_size /* points, nb_points*/ , verbose_level);
STAB.compute_set_stabilizer(t0, nb_backtrack_nodes, Aut_gens, verbose_level + 10);
longinteger_object go, go2;
Stab = Aut_gens->create_sims(verbose_level - 1);
Stab->group_order(go);
cout << "computing stabilizer of conic done, found a group of order " << go << endl;
delete Stab;
}
else {
Aut_gens = NULL;
}
{
BYTE fname[1000];
{
mp_graphics *G;
INT f_include_line_at_infinity = TRUE;
sprintf(fname, "conic_%ld", q);
draw_beginning(fname, G, xmax, ymax, verbose_level);
//variety_size = 0;
draw_grid_(*G, q, f_include_line_at_infinity, verbose_level);
draw_points(*G, P, /*variety + 3, 5*/ variety, variety_size /*points, nb_points*/, verbose_level);
draw_end(fname, G, xmax, ymax, verbose_level);
}
if (f_do_stabilizer) {
prepare_latex(fname, P, points, nb_points, Aut_gens, verbose_level);
}
}
delete Aut_gens;
return;
P->find_tangent_lines_to_conic(six_coeffs,
points, nb_points,
tangents, verbose_level);
cout << "the " << nb_points << " tangent lines are: ";
INT_vec_print(cout, tangents, nb_points);
cout << endl;
nb_exterior_points = (nb_points * (nb_points - 1)) >> 1;
nb_secants = nb_exterior_points;
exterior_points = NEW_INT(nb_exterior_points);
h = 0;
for (i = 0; i < nb_points; i++) {
for (j = i + 1; j < nb_points; j++) {
exterior_points[h++] = P->Line_intersection[
tangents[i] * P->N_lines + tangents[j]];
}
}
INT_vec_heapsort(exterior_points, nb_exterior_points);
cout << "the " << nb_exterior_points << " exterior points are: ";
INT_vec_print(cout, exterior_points, nb_exterior_points);
cout << endl;
secants = NEW_INT(nb_secants);
h = 0;
for (i = 0; i < nb_points; i++) {
for (j = i + 1; j < nb_points; j++) {
secants[h++] = P->Line_through_two_points[
points[i] * P->N_points + points[j]];
}
}
INT_vec_heapsort(secants, nb_secants);
cout << "the " << nb_secants << " secants are: ";
INT_vec_print(cout, secants, nb_secants);
cout << endl;
INT *external_lines;
INT nb_external_lines;
external_lines = NEW_INT(P->N_lines);
for (i = 0; i < P->N_lines; i++) {
external_lines[i] = i;
}
nb_external_lines = P->N_lines;
set_delete_elements(external_lines, nb_external_lines, tangents, nb_points);
set_delete_elements(external_lines, nb_external_lines, secants, nb_secants);
cout << "the " << nb_external_lines << " external lines are: ";
INT_vec_print(cout, external_lines, nb_external_lines);
cout << endl;
INT *adjacency;
INT idx;
adjacency = NEW_INT(nb_external_lines * nb_external_lines);
for (i = 0; i < nb_external_lines; i++) {
adjacency[i * nb_external_lines + i] = 0;
for (j = i + 1; j < nb_external_lines; j++) {
a = P->Line_intersection[
external_lines[i] * P->N_lines + external_lines[j]];
if (INT_vec_search(exterior_points, nb_exterior_points, a, idx)) {
adjacency[i * nb_external_lines + j] = 1;
adjacency[j * nb_external_lines + i] = 1;
}
else {
adjacency[i * nb_external_lines + j] = 0;
adjacency[j * nb_external_lines + i] = 0;
}
}
}
cout << "adjacency matrix:" << endl;
print_integer_matrix_width(cout, adjacency,
nb_external_lines, nb_external_lines, nb_external_lines,
1);
INT *Edges1;
INT *Edges2;
INT *Incidence;
INT nb_e = 0;
for (i = 0; i < nb_external_lines; i++) {
for (j = i + 1; j < nb_external_lines; j++) {
if (adjacency[i * nb_external_lines + j])
nb_e++;
}
}
Edges1 = NEW_INT(nb_e);
Edges2 = NEW_INT(nb_e);
Incidence = NEW_INT(nb_external_lines * nb_e);
for (i = 0; i < nb_external_lines * nb_e; i++) {
Incidence[i] = 0;
}
nb_e = 0;
for (i = 0; i < nb_external_lines; i++) {
for (j = i + 1; j < nb_external_lines; j++) {
if (adjacency[i * nb_external_lines + j]) {
Edges1[nb_e] = i;
Edges2[nb_e] = j;
nb_e ++;
}
}
}
for (j = 0; j < nb_e; j++) {
Incidence[Edges1[j] * nb_e + j] = 1;
Incidence[Edges2[j] * nb_e + j] = 1;
}
BYTE fname[1000];
sprintf(fname, "ext_lines_%ld.inc", P->F->q);
{
ofstream f(fname);
f << nb_external_lines << " " << nb_e << " " << nb_e * 2 << endl;
for (i = 0; i < nb_external_lines * nb_e; i++) {
if (Incidence[i]) {
f << i << " ";
}
}
f << endl;
f << -1 << endl;
}
cout << "written file " << fname << " of size " << file_size(fname) << endl;
INT colors[] = {0,1};
INT C = 2;
INT *Pijk;
Pijk = NEW_INT(C * C * C);
if (analyze_color_graph(C, colors, nb_external_lines, adjacency, Pijk, verbose_level)) {
cout << "is association scheme" << endl;
}
else {
cout << "not an association scheme" << endl;
}
//exit(1);
{
set_stabilizer_compute STAB;
strong_generators *Aut_gens;
sims *Stab;
//vector_ge gens;
//INT *tl;
INT nb_backtrack_nodes;
cout << "computing stabilizer of conic:" << endl;
STAB.init(A, points, nb_points, verbose_level);
STAB.compute_set_stabilizer(t0, nb_backtrack_nodes, Aut_gens, verbose_level + - 2);
Stab = Aut_gens->create_sims(verbose_level - 1);
longinteger_object go, go2;
Stab->group_order(go);
cout << "computing stabilizer of conic done, found a group of order " << go << endl;
action *A2;
action A2r;
INT f_induce_action = TRUE;
projective_space_init_line_action(P, A, A2, verbose_level);
A2r.induced_action_by_restriction(*A2,
f_induce_action, Stab,
nb_external_lines, external_lines, verbose_level);
A2r.group_order(go2);
cout << "induced action on external lines has order " << go2 << endl;
for (i = 0; i < Aut_gens->gens->len; i++) {
A2r.element_print_quick(Aut_gens->gens->ith(i), cout);
A2->element_print_as_permutation(Aut_gens->gens->ith(i), cout);
A2r.element_print_as_permutation(Aut_gens->gens->ith(i), cout);
}
delete Aut_gens;
delete Stab;
delete A2;
}
}
void particles_render::draw(const explosion &e) const
{
clear_points();
const float life_time = 5.0f;
for (int i = 0; i < 2; ++i)
{
auto &rots = i == 0 ? e.m_shrapnel_rots : e.m_shrapnel2_rots;
auto &tis = i == 0 ? e.m_shrapnel_alpha_tc_idx : e.m_shrapnel2_alpha_tc_idx;
for (size_t j = 0; j < rots.size(); ++j)
{
auto &r = rots[j];
auto &ti = tis[j];
auto nt = e.m_time / life_time;
const int tc_w_count = 16;
const int tc_h_count = 2;
const int tc_idx = (tc_w_count * tc_h_count + 1) * nt;
float l = nya_math::min(e.m_time / 2.0f, 1.0f) * e.m_radius * 1.6f;
auto ctc = tc(0, 512, 128, 128);
ctc.x += ctc.z * (tc_idx % tc_w_count);
ctc.y += ctc.w * (tc_idx / tc_w_count);
auto atc = i == 0 ? tc(1920, 768, 64, 256) : tc(1664, 768, 128, 256);
atc.x += atc.z * ti;
auto c = color(1.0f, 1.0f, 1.0f, 1.0f);
if (e.m_time > 1.0)
c.w -= (e.m_time - 1.0);
add_point(e.m_pos, l, ctc, true, atc, false, c, nya_math::vec2(0.0f, -0.9f), r, i == 0 ? 0.4f : 0.2f);
}
//
}
//fire
for (size_t i = 0; i < e.m_fire_dirs.size(); ++i)
{
auto &d = e.m_fire_dirs[i];
auto &ti = e.m_fire_alpha_tc_idx[i];
auto nt = e.m_time / life_time;
auto t = nya_math::min(e.m_time, 1.0f) + nt * 0.1f;
auto p = e.m_pos + d * t * e.m_radius * 0.25f;
auto r = e.m_radius * t * 0.75f;
const int tc_w_count = 16;
const int tc_h_count = 2;
const int tc_idx = (tc_w_count * tc_h_count + 1) * nya_math::min(e.m_time / 2.0f, 1.0f);
auto ctc = tc(0, 0, 128, 128);
ctc.x += ctc.z * (tc_idx % tc_w_count);
ctc.y += ctc.w * (tc_idx / tc_w_count);
auto atc = tc(0, 1920, 128, 128);
atc.x += atc.z * ti;
auto c = color(hdr_coeff, hdr_coeff, hdr_coeff, 0.7f);
if (e.m_time > 1.5)
c.w -= (e.m_time - 1.5);
add_point(p, r, ctc, false, atc, true, c, nya_math::vec2(), e.m_fire_rots[i]);
}
draw_points();
}
void match_score_layer_draw_score(Score* score){
draw_who_serves(score);
draw_points(score);
draw_games(score);
draw_sets(score);
}
void draw_stroke(SkCanvas* canvas, const SkPath& path, SkScalar width, SkScalar scale,
bool drawText) {
if (path.isEmpty()) {
return;
}
SkRect bounds = path.getBounds();
this->setWHZ(SkScalarCeilToInt(bounds.right()), drawText
? SkScalarRoundToInt(scale * 3 / 2) : SkScalarRoundToInt(scale),
SkScalarRoundToInt(950.0f / scale));
erase(fMinSurface);
SkPaint paint;
paint.setColor(0x1f1f0f0f);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(width * scale * scale);
paint.setColor(0x3f0f1f3f);
if (drawText) {
fMinSurface->getCanvas()->drawPath(path, paint);
this->copyMinToMax();
fMaxSurface->draw(canvas, 0, 0, NULL);
}
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(1);
paint.setColor(SKELETON_COLOR);
SkPath scaled;
SkMatrix matrix;
matrix.reset();
matrix.setScale(950 / scale, 950 / scale);
if (drawText) {
path.transform(matrix, &scaled);
} else {
scaled = path;
}
canvas->drawPath(scaled, paint);
draw_points(canvas, scaled, SKELETON_COLOR, true);
if (fDrawRibs) {
draw_ribs(canvas, scaled, width, 0xFF00FF00);
}
SkPath fill;
SkPaint p;
p.setStyle(SkPaint::kStroke_Style);
if (drawText) {
p.setStrokeWidth(width * scale * scale);
} else {
p.setStrokeWidth(width);
}
p.getFillPath(path, &fill);
SkPath scaledFill;
if (drawText) {
fill.transform(matrix, &scaledFill);
} else {
scaledFill = fill;
}
paint.setColor(WIREFRAME_COLOR);
canvas->drawPath(scaledFill, paint);
draw_points(canvas, scaledFill, WIREFRAME_COLOR, false);
}
