gm_vizp.cpp

算断裂的

      
      for (unsigned int subsetmask = 0; 
      subsetmask < (1 << (fdim + 1));
      ++subsetmask) {
        selected_verts.resize(0);
        for (int j = 0; j < fdim + 1; ++j) {
          if (subsetmask & (1<<j)) selected_verts.push_back(j);
        }
        if (selected_verts.size() != dim + 1) continue;


        for (Brep::FaceIndex faceind = 0; faceind < levsize; ++faceind) {
          Brep::Face_Spec fspec(fdim, faceind);
          int nmf = sc.num_meshface_on_face(fspec);
          
          
          // Get all the subfaces with the selected vertices.
          
          for (int seqno = 0; seqno < nmf; ++seqno) {
            for (int l = 0; l < dim + 1; ++l) {
              SimpComplex::VertexGlobalIndex vnum = 
                sc.node_of_meshface_on_face(fspec, seqno, selected_verts[l]);
              key.verts[l] = sc.global_to_ordinal(vnum);
            }
            key.sort();
            if (faces_drawn[key] == 0) {
              faces_drawn[key] = 1;
              Colorspec cspec = colortable[fspec];
              for (int l1 = 0; l1 < dim + 1; ++l1) {
                outputsimps.push_back(key.verts[l1]);
              }
              colors.push_back(cspec);
            }
          }
        }
      }
    }
  

    int outputcount = outputsimps.size() / (dim + 1);
    IntMatrix faces(outputcount, dim + 1);
    Matrix colorso(outputcount, 4);
    int pos = 0;
    for (int ocount = 0; ocount < outputcount; ++ocount) {
      for (int l = 0; l < dim + 1; ++l) {
        faces(ocount, l) = outputsimps[pos++];
      }
      for (int cc = 0; cc < 4; ++cc) {
        colorso(ocount, cc) = colors[ocount].co[cc];
      }
    }
    return Vizp_data(vc, faces, colorso);
  }
    

  // ------------------------------------------------------------------
  // This routine is for extracting coordinates and simplices
  // from a brep.  The routine generates only straight segments
  // and triangles, so curved objects are approximated via subdivision.
  // The argument beziersub determines how many pieces to
  // in which to subdivide.


  Vizp_data get_pts_simps(const Brep& g, 
    const vector<Real>& default_color,
    int dim, 
    int beziersub) {

    int di = g.embedded_dim();
    Point::init_static_data(di);
    int gdim = g.gdim();
    if (dim > gdim || dim < 0)
      throw_error("dim argument out of range in get_pts_simps");
    if (default_color.size() != 4)
      throw_error("Wrong color length in get_pts_simps");
    if (beziersub < 0 || beziersub > 10000)
      throw_error("Beziersub out of range in get_pts_simps");
    Point realcoord;
    Point paramcoord;
    int pcount = 0;
    vector<Real> pt_coords;
    vector<int> simp_vtx;
    vector<Colorspec> colors;
    for (Brep::Face_Spec_Loop_Over_Faces_Of_Dim fspec(g, dim);
    fspec.notdone();
    ++fspec) {

      Colorspec facecolor = parse_color_propval(g,fspec);
      if (facecolor.co[0] < 0) {
        for (int j = 0; j < 4; ++j)
          facecolor.co[j] = default_color[j];
      }

      for (Brep::Loop_over_patches_of_face patch(g, fspec);
      patch.notdone();
      ++patch) {
        int pbase = pcount;
        if (dim == 0) {
          Brep::ControlPointIndex cpi = patch.control_point(0);  
          for (int i = 0; i < di; ++i)
            pt_coords.push_back(g.control_point(cpi,i));
          ++pcount;      
          simp_vtx.push_back(pbase);
          colors.push_back(facecolor);

        }
        else if (dim == 1) {
          int subdiv = (patch.degree1() == 1)? 1 : beziersub;
          for (int vcount = 0; vcount <= subdiv; ++vcount) {
            paramcoord[0] = static_cast<double>(vcount) /
              static_cast<double>(subdiv);
            realcoord = g.patchmath(fspec, patch.index()).
              get_real_point(paramcoord);
            for (int i = 0; i < di; ++i)
              pt_coords.push_back(realcoord[i]);
            ++pcount;
          }
          for (int sub = 0; sub < subdiv; ++sub) {
            simp_vtx.push_back(pbase + sub);
            simp_vtx.push_back(pbase + sub + 1);
            colors.push_back(facecolor);
          }
        }
        else if (dim == 2) {
          if (patch.ptype() == BEZIER_TRIANGLE) {
            int subdiv = (patch.degree1() == 1)? 1 : beziersub;
            {
              for (int rownum = 0; rownum <= subdiv; ++rownum) {
                for (int colnum = 0; colnum <= rownum; ++colnum) {
                  paramcoord[0] = static_cast<double>(colnum) / 
                    static_cast<double>(subdiv);
                  paramcoord[1] = static_cast<double>(rownum-colnum) /
                    static_cast<double>(subdiv);
                  realcoord = g.patchmath(fspec, patch.index()).
                    get_real_point(paramcoord);
                  for (int i = 0; i < di; ++i)
                    pt_coords.push_back(realcoord[i]);
                  ++pcount;
                }
              }
            }
            int sub = 0;
            {
              for (int rownum = 0; rownum < subdiv; ++rownum) {
                for (int colnum = 0; colnum <= rownum; ++colnum) {
                  simp_vtx.push_back(pbase + sub);
                  simp_vtx.push_back(pbase + sub + rownum + 1);
                  simp_vtx.push_back(pbase + sub + rownum + 2);
                  colors.push_back(facecolor);
                  if (rownum < subdiv - 1) {
                    simp_vtx.push_back(pbase + sub + rownum + 2);
                    simp_vtx.push_back(pbase + sub + rownum + 1);
                    simp_vtx.push_back(pbase + sub + 2 * rownum + 4);
                    colors.push_back(facecolor);
                  }
                  ++sub;
                }
              }
            }
          }
          else { //patchtype == QUAD
            int subdiv1 = beziersub;
            int subdiv2 = beziersub;
            {
              for (int rownum = 0; rownum <= subdiv2; ++rownum) {
                for (int colnum = 0; colnum <= subdiv1; ++colnum) {
                  paramcoord[0] = static_cast<double>(colnum) / 
                    static_cast<double>(subdiv1);
                  paramcoord[1] = static_cast<double>(rownum) /
                    static_cast<double>(subdiv2);
                  realcoord = g.patchmath(fspec, patch.index()).
                    get_real_point(paramcoord);
                  for (int i = 0; i < di; ++i)
                    pt_coords.push_back(realcoord[i]);
                  ++pcount;
                }
              }
            }
            {
              for (int rownum = 0; rownum < subdiv2; ++rownum) {
                for (int colnum = 0; colnum < subdiv1; ++colnum) {
                  int startpoint = colnum + (rownum * (subdiv1 + 1));
                  simp_vtx.push_back(pbase + startpoint);
                  simp_vtx.push_back(pbase + startpoint + subdiv1 + 2);
                  simp_vtx.push_back(pbase + startpoint + subdiv1 + 1);
                  simp_vtx.push_back(pbase + startpoint);
                  simp_vtx.push_back(pbase + startpoint + 1);
                  simp_vtx.push_back(pbase + startpoint + subdiv1 + 2);
                  for (int c0 = 0; c0 < 2; ++c0) {
                    colors.push_back(facecolor);
                  }
                }
              }
            }
          }
        }
      }
    }
    int numsimp = simp_vtx.size() / (dim + 1);
#ifdef DEBUGGING
    if (pt_coords.size() != pcount * di ||
      simp_vtx.size() != numsimp * (dim + 1) ||
      colors.size() != numsimp)
      throw_error("Array size error in gm_vizp");
#endif

    int pos = 0;
    Matrix coord(pcount,di);
    for (int j1 = 0; j1 < pcount; ++j1)
      for (int d = 0; d < di; ++d)
        coord(j1,d) = pt_coords[pos++];
    int pos1 = 0;
    IntMatrix simpv(numsimp, dim + 1);
    Matrix colorm(numsimp, 4);
    for (int j2 = 0; j2 < numsimp; ++j2) {
      for (int d = 0; d < dim + 1; ++d)
        simpv(j2, d) = simp_vtx[pos1++];
      for (int c = 0; c < 4; ++c)
        colorm(j2, c) = colors[j2].co[c];
    }

    return Vizp_data(coord, simpv, colorm);
  }
  

#define GM_ROUTINE_NAME gm_vizp
#define GM_ROUTINE_NAME_Q "gm_vizp"


  // ------------------------------------------------------------------
  // This is the driver for gm_vizp and is a standard driver.
  
  static void worker(const QMG::FrontEnd::ArgValType& argvalhandle,
    QMG::FrontEnd::ReturnValType& returnvalhandle,
    QMG::FrontEnd::Interpreter& interp) {
    
    using namespace QMG;
    using namespace QMG::FrontEnd;
    
    argvalhandle.verify_nargin(4, 5, GM_ROUTINE_NAME_Q);
    returnvalhandle.verify_nargout(3,3, GM_ROUTINE_NAME_Q);

    // possible calling sequences:

    // gm_vizp(brep, default_color, dim, bezier_sub)
    // gm_vizp(simpcomp, default_color, dim, unused)
    // gm_vizp(simpcomp, brep, default_color, dim, unused)

    if (argvalhandle.nargin() == 4) {
      Object_Type_Code code = argvalhandle.determine_argument_type(0);
      if (code == UNKNOWN)
        throw_error("Argument 0 could not be interpreted as brep or simpcomplex");      
      if (code == BREP) {      
        Vizp_data vizpdata = get_pts_simps(argvalhandle.get_brep(0), 
          argvalhandle.get_vector_double(1),
          argvalhandle.get_int(2), 
          argvalhandle.get_int(3));
        returnvalhandle.put_matrix(0, vizpdata.coords);
        returnvalhandle.put_intmatrix(1, vizpdata.simps);
        returnvalhandle.put_matrix(2, vizpdata.colors);
        return;
      }
      else {      
        Vizp_data vizpdata = get_pts_simps(argvalhandle.get_simpcomp(0), 
          argvalhandle.get_vector_double(1),
          argvalhandle.get_int(2)); 
        returnvalhandle.put_matrix(0, vizpdata.coords);
        returnvalhandle.put_intmatrix(1, vizpdata.simps);
        returnvalhandle.put_matrix(2, vizpdata.colors);
        return;
      }
    }
 
    else { // nargin = 5
      Vizp_data vizpdata = get_pts_simps(argvalhandle.get_simpcomp(0),
        argvalhandle.get_brep(1),
        argvalhandle.get_vector_double(2),
        argvalhandle.get_int(3));
      returnvalhandle.put_matrix(0, vizpdata.coords);
      returnvalhandle.put_intmatrix(1, vizpdata.simps);
      returnvalhandle.put_matrix(2, vizpdata.colors);
    }
    return;
  }
}

#include "gm_entrypoint.cpp"