Esempio n. 1
0
Cube :: Cube(float my_size)
{
	// adjust size to form around the origin
	h = my_size/2.0;
	
	// define number of vertices
	verts_size = 8;
	verts = new GLfloat*[verts_size];
	
	// define the number of faces
	faces_size = 12;
	faces = new int*[faces_size];
	
	// define arrays for normals
	v_norms = new GLfloat*[verts_size];
	f_norms = new GLfloat*[faces_size];
	
	// VERTICES
	/////////////////////////////////////////////
	
	// front-top-right corner
	make_vert(0, -h, h, h);
	
	// front-bottom-right corner
	make_vert(1, -h, -h, h);
	
	// front-bottom-left corner
	make_vert(2, h, -h, h);
	
	// front-top-left corner
	make_vert(3, h, h, h);
	
	// back-top-right corner
	make_vert(4, -h, h, -h);
	
	// back-bottom-right corner
	make_vert(5, -h, -h, -h);
	
	// back-bottom-left corner
	make_vert(6, h, -h, -h);
	
	// back-top-left corner
	make_vert(7, h, h, -h);
	
	// FACES + NORMALS
	/////////////////////////////////////////////
	
	// front face 1
	make_face(0, 3, 2, 1);
														
	// front face 2
	make_face(1, 3, 1, 0);
	
	// left face 1
	make_face(2, 7, 6, 2);
	
	// left face 2
	make_face(3, 7, 2, 3);
	
	// back face 1
	make_face(4, 4, 5, 6);
	
	// back face 2
	make_face(5, 4, 6, 7);
	
	// right face 1
	make_face(6, 0, 1, 5);
	
	// right face 2
	make_face(7, 0, 5, 4);
	
	// top face 1
	make_face(8, 7, 3, 0);
	
	// top face 2
	make_face(9, 7, 0, 4);
	
	// bottom face 1
	make_face(10, 2, 6, 5);
	
	// bottom face 2
	make_face(11, 2, 5, 1);
	
	// VERTEX NORMALS
	/////////////////////////////////////////////
	// NOTE: The cube vertices have a varying
	// number of faces (some of which have the same normal).
	// This makes calculating the normals difficult.
	// Because there are only 8 vertices,
	// it is simple enough to just hard code them in.
	
	v_norms[0][0] = -1.0/3.0;
	v_norms[0][1] = 1.0/3.0;
	v_norms[0][2] = 1.0/3.0;
	v_norms[0][3] = 1.0;
	
	v_norms[1][0] = -1.0/3.0;
	v_norms[1][1] = -1.0/3.0;
	v_norms[1][2] = 1.0/3.0;
	v_norms[1][3] = 1.0;
	
	v_norms[2][0] = 1.0/3.0;
	v_norms[2][1] = -1.0/3.0;
	v_norms[2][2] = 1.0/3.0;
	v_norms[2][3] = 1.0;
	
	v_norms[3][0] = 1.0/3.0;
	v_norms[3][1] = 1.0/3.0;
	v_norms[3][2] = 1.0/3.0;
	v_norms[3][3] = 1.0;
	
	v_norms[4][0] = -1.0/3.0;
	v_norms[4][1] = 1.0/3.0;
	v_norms[4][2] = -1.0/3.0;
	v_norms[4][3] = 1.0;
	
	v_norms[5][0] = -1.0/3.0;
	v_norms[5][1] = -1.0/3.0;
	v_norms[5][2] = -1.0/3.0;
	v_norms[5][3] = 1.0;
	
	v_norms[6][0] = 1.0/3.0;
	v_norms[6][1] = -1.0/3.0;
	v_norms[6][2] = -1.0/3.0;
	v_norms[6][3] = 1.0;
	
	v_norms[7][0] = 1.0/3.0;
	v_norms[7][1] = 1.0/3.0;
	v_norms[7][2] = -1.0/3.0;
	v_norms[7][3] = 1.0;
	
}
Esempio n. 2
0
      void Orderizer::process_space(SpaceSharedPtr<Scalar> space, bool show_edge_orders)
      {
        // sanity check
        if (space == nullptr)
          throw Hermes::Exceptions::Exception("Space is nullptr in Orderizer:process_space().");

        if (!space->is_up_to_date())
          throw Hermes::Exceptions::Exception("The space is not up to date.");

        MeshSharedPtr mesh = space->get_mesh();

        // Reallocate.
        this->reallocate(mesh);

        RefMap refmap;

        int oo, o[6];

        // make a mesh illustrating the distribution of polynomial orders over the space
        Element* e;
        for_all_active_elements(e, mesh)
        {
          oo = o[4] = o[5] = space->get_element_order(e->id);
          if (show_edge_orders)
          for (unsigned int k = 0; k < e->get_nvert(); k++)
            o[k] = space->get_edge_order(e, k);
          else if (e->is_curved())
          {
            if (e->is_triangle())
            for (unsigned int k = 0; k < e->get_nvert(); k++)
              o[k] = oo;
            else
            for (unsigned int k = 0; k < e->get_nvert(); k++)
              o[k] = H2D_GET_H_ORDER(oo);
          }

          double3* pt;
          int np;
          double* x;
          double* y;
          if (show_edge_orders || e->is_curved())
          {
            refmap.set_quad_2d(&quad_ord);
            refmap.set_active_element(e);
            x = refmap.get_phys_x(1);
            y = refmap.get_phys_y(1);

            pt = quad_ord.get_points(1, e->get_mode());
            np = quad_ord.get_num_points(1, e->get_mode());
          }
          else
          {
            refmap.set_quad_2d(&quad_ord_simple);
            refmap.set_active_element(e);
            x = refmap.get_phys_x(1);
            y = refmap.get_phys_y(1);

            pt = quad_ord_simple.get_points(1, e->get_mode());
            np = quad_ord_simple.get_num_points(1, e->get_mode());
          }

          int id[80];
          assert(np <= 80);

          int mode = e->get_mode();
          if (e->is_quad())
          {
            o[4] = H2D_GET_H_ORDER(oo);
            o[5] = H2D_GET_V_ORDER(oo);
          }
          if (show_edge_orders || e->is_curved())
          {
            make_vert(lvert[label_count], x[0], y[0], o[4]);

            for (int i = 1; i < np; i++)
              make_vert(id[i - 1], x[i], y[i], o[(int)pt[i][2]]);

            for (int i = 0; i < num_elem[mode][1]; i++)
              this->add_triangle(id[ord_elem[mode][1][i][0]], id[ord_elem[mode][1][i][1]], id[ord_elem[mode][1][i][2]], e->marker);

            for (int i = 0; i < num_edge[mode][1]; i++)
            {
              if (e->en[ord_edge[mode][1][i][2]]->bnd || (y[ord_edge[mode][1][i][0] + 1] < y[ord_edge[mode][1][i][1] + 1]) ||
                ((y[ord_edge[mode][1][i][0] + 1] == y[ord_edge[mode][1][i][1] + 1]) &&
                (x[ord_edge[mode][1][i][0] + 1] < x[ord_edge[mode][1][i][1] + 1])))
              {
                add_edge(id[ord_edge[mode][1][i][0]], id[ord_edge[mode][1][i][1]], e->en[ord_edge[mode][1][i][2]]->marker);
              }
            }
          }
          else
          {
            make_vert(lvert[label_count], x[0], y[0], o[4]);

            for (int i = 1; i < np; i++)
              make_vert(id[i - 1], x[i], y[i], o[(int)pt[i][2]]);

            for (int i = 0; i < num_elem_simple[mode][1]; i++)
              this->add_triangle(id[ord_elem_simple[mode][1][i][0]], id[ord_elem_simple[mode][1][i][1]], id[ord_elem_simple[mode][1][i][2]], e->marker);

            for (int i = 0; i < num_edge_simple[mode][1]; i++)
              add_edge(id[ord_edge_simple[mode][1][i][0]], id[ord_edge_simple[mode][1][i][1]], e->en[ord_edge_simple[mode][1][i][2]]->marker);
          }

          double xmin = 1e100, ymin = 1e100, xmax = -1e100, ymax = -1e100;
          for (unsigned int k = 0; k < e->get_nvert(); k++)
          {
            if (e->vn[k]->x < xmin) xmin = e->vn[k]->x;
            if (e->vn[k]->x > xmax) xmax = e->vn[k]->x;
            if (e->vn[k]->y < ymin) ymin = e->vn[k]->y;
            if (e->vn[k]->y > ymax) ymax = e->vn[k]->y;
          }
          lbox[label_count][0] = xmax - xmin;
          lbox[label_count][1] = ymax - ymin;
          ltext[label_count++] = labels[o[4]][o[5]];
        }
Esempio n. 3
0
void Orderizer::process_solution(Space* space)
{
  // sanity check
  if (space == NULL) error("Space is NULL in Orderizer:process_solution().");

  if (!space->is_up_to_date())
    error("The space is not up to date.");

  int type = 1;

  nv = nt = ne = nl = 0;
  del_slot = -1;

  // estimate the required number of vertices and triangles
  Mesh* mesh = space->get_mesh();
  if (mesh == NULL) {
    error("Mesh is NULL in Orderizer:process_solution().");
  }
  int nn = mesh->get_num_active_elements();
  int ev = 77 * nn, et = 64 * nn, ee = 16 * nn, el = nn + 10;

  // reuse or allocate vertex, triangle and edge arrays
  lin_init_array(verts, double3, cv, ev);
  lin_init_array(tris, int3, ct, et);
  lin_init_array(edges, int3, ce, ee);
  lin_init_array(lvert, int, cl1, el);
  lin_init_array(ltext, char*, cl2, el);
  lin_init_array(lbox, double2, cl3, el);
  info = NULL;

  int oo, o[6];

  RefMap refmap;
  refmap.set_quad_2d(&quad_ord);

  // make a mesh illustrating the distribution of polynomial orders over the space
  Element* e;
  for_all_active_elements(e, mesh)
  {
    oo = o[4] = o[5] = space->get_element_order(e->id);
    for (unsigned int k = 0; k < e->nvert; k++)
      o[k] = space->get_edge_order(e, k);

    refmap.set_active_element(e);
    double* x = refmap.get_phys_x(type);
    double* y = refmap.get_phys_y(type);

    double3* pt = quad_ord.get_points(type);
    int np = quad_ord.get_num_points(type);
    int id[80];
    assert(np <= 80);

    #define make_vert(index, x, y, val) \
      { (index) = add_vertex(); \
      verts[index][0] = (x); \
      verts[index][1] = (y); \
      verts[index][2] = (val); }

    int mode = e->get_mode();
    if (e->is_quad())
    {
      o[4] = H2D_GET_H_ORDER(oo);
      o[5] = H2D_GET_V_ORDER(oo);
    }
    make_vert(lvert[nl], x[0], y[0], o[4]);

    for (int i = 1; i < np; i++)
      make_vert(id[i-1], x[i], y[i], o[(int) pt[i][2]]);

    for (int i = 0; i < num_elem[mode][type]; i++)
      add_triangle(id[ord_elem[mode][type][i][0]], id[ord_elem[mode][type][i][1]], id[ord_elem[mode][type][i][2]]);

    for (int i = 0; i < num_edge[mode][type]; i++)
    {
      if (e->en[ord_edge[mode][type][i][2]]->bnd || (y[ord_edge[mode][type][i][0] + 1] < y[ord_edge[mode][type][i][1] + 1]) ||
          ((y[ord_edge[mode][type][i][0] + 1] == y[ord_edge[mode][type][i][1] + 1]) &&
           (x[ord_edge[mode][type][i][0] + 1] <  x[ord_edge[mode][type][i][1] + 1])))
      {
        add_edge(id[ord_edge[mode][type][i][0]], id[ord_edge[mode][type][i][1]], 0);
      }
    }

    double xmin = 1e100, ymin = 1e100, xmax = -1e100, ymax = -1e100;
    for (unsigned int k = 0; k < e->nvert; k++)
    {
      if (e->vn[k]->x < xmin) xmin = e->vn[k]->x;
      if (e->vn[k]->x > xmax) xmax = e->vn[k]->x;
      if (e->vn[k]->y < ymin) ymin = e->vn[k]->y;
      if (e->vn[k]->y > ymax) ymax = e->vn[k]->y;
    }
    lbox[nl][0] = xmax - xmin;
    lbox[nl][1] = ymax - ymin;
    ltext[nl++] = labels[o[4]][o[5]];
  }