ObjHelper Namespace Reference

Classes
struct	VtnCounter
	This is the counter struct for keeping track of the vertices. More...

Functions
void	writeVTN (std::ofstream &stream, VtnCounter &vtnCounter, double scalor, const Acts::Vector3 &vertex, const std::string &vtntype="v", bool point=false)
	This will write a vertex to the fstream. More...
void	constructVerticalFaces (std::ofstream &stream, unsigned int start, const std::vector< unsigned int > &vsides)
	construct vertical faces this takes a range and constructs faces More...
void	writePlanarFace (std::ofstream &stream, VtnCounter &vtnCounter, double scalor, const std::vector< Acts::Vector3 > &vertices, double thickness=0., const std::vector< unsigned int > &vsides={})
	This will write a planar face. More...
void	writeTube (std::ofstream &stream, VtnCounter &vtnCounter, double scalor, unsigned int nSegments, const Acts::Transform3 &transform, double r, double hZ, double thickness=0.)
	This will write a cylindrical object. More...

Function Documentation

constructVerticalFaces()

void ObjHelper::constructVerticalFaces	(	std::ofstream &	stream,
		unsigned int	start,
		const std::vector< unsigned int > &	vsides
	)

construct vertical faces this takes a range and constructs faces

Definition at line 42 of file ObjHelper.cxx.

{
  // construct the vertical faces
  size_t       nsides = vsides.size();
  unsigned int sstart = start;
  for (auto vside : vsides) {
    if (vside) {
      // start streaming the side
      // all but the last
      if (start - sstart < nsides - 1) {
        stream << "f " << start << " " << start + 1 << " ";
        stream << start + nsides + 1 << " " << start + nsides;
      } else {
        stream << "f " << start << " " << sstart << " ";
        stream << sstart + nsides << " " << start + nsides;
      }
    }
    stream << '\n';
    // increase
    ++start;
  }
}

writePlanarFace()

void ObjHelper::writePlanarFace	(	std::ofstream &	stream,
		VtnCounter &	vtnCounter,
		double	scalor,
		const std::vector< Acts::Vector3 > &	vertices,
		double	thickness = 0.,
		const std::vector< unsigned int > &	vsides = {}
	)

This will write a planar face.

• normal is given by cross product

Parameters

stream	is the stream where to write to
face	is the face to be written out
cvertex	is the current vertex number
thickness	is the (optional) thickness

Definition at line 69 of file ObjHelper.cxx.

{
  // minimum 3 vertices needed
  if (vertices.size() < 3) return;
  // the first vertex
  unsigned int fvertex = vtnCounter.vcounter + 1;
  // lets create the normal vector first
  Acts::Vector3 sideOne = vertices[1] - vertices[0];
  Acts::Vector3 sideTwo = vertices[2] - vertices[1];
  Acts::Vector3 nvector(sideTwo.cross(sideOne).normalized());
  // write the normal vector
  writeVTN(stream, vtnCounter, scalor, nvector, "n");
  // thickness or not thickness
  std::vector<int> sides     = {1};
  if (thickness != 0.) sides = {-1, 1};
  // now write all the vertices - this works w/wo thickness
  for (auto side : sides) {
    // save the current vertex counter
    unsigned int cvc = vtnCounter.vcounter;
    // loop over the sides
    for (auto v : vertices)
      writeVTN(stream,
               vtnCounter,
               scalor,
               v + (0.5 * side * thickness) * nvector,
               "v");
    // decide if you want to add texture
    std::string vtphr
        = "/";  // vtnCounter.vtcounter ? "/"+std::to_string(vtcounter) : "/";
    std::string ntphr = "/" + std::to_string(vtnCounter.ncounter);
    // now write the face
    stream << "f ";
    for (size_t i=0;i<vertices.size();++i) stream << ++cvc << vtphr << ntphr << " ";
    stream << '\n';
  }
  // now process the vertical sides
  constructVerticalFaces(stream, fvertex, vsides);
}

writeTube()

void ObjHelper::writeTube	(	std::ofstream &	stream,
		VtnCounter &	vtnCounter,
		double	scalor,
		unsigned int	nSegments,
		const Acts::Transform3 &	transform,
		double	r,
		double	hZ,
		double	thickness = 0.
	)

This will write a cylindrical object.

Parameters

stream

is the stream where to write to

Definition at line 114 of file ObjHelper.cxx.

{
  // flip along plus/minus and declare the faces
  std::vector<int> flip   = {-1, 1};
  std::vector<int> vfaces = {1, 2, 4, 3};
  // the number of phisteps
  double phistep = 2 * M_PI / nSegments;
  // make it twice if necessary
  std::vector<double> roffsets  = {0.};
  if (thickness != 0.) roffsets = {-0.5 * thickness, 0.5 * thickness};
  // now loop over the thickness and make an outer and inner
  unsigned int cvc   = vtnCounter.vcounter;
  size_t       iside = 0;
  for (auto t : roffsets) {
    size_t iphi = 0;
    // loop over phi steps
    for (; iphi < nSegments; ++iphi) {
      // currentPhi
      double phi = -M_PI + iphi * phistep;
      for (auto iflip : flip) {
        // create the vertex
        Acts::Vector3 point(transform * Acts::Vector3((r + t) * cos(phi),
                                                        (r + t) * sin(phi),
                                                        iflip * hZ));
        // write the normal vector
        writeVTN(stream, vtnCounter, scalor, point, "v");
      }
    }
    // now create the faces
    iphi = 0;
    // side offset for faces
    unsigned int soff = 2 * iside * nSegments;
    for (; iphi < nSegments - 1; ++iphi) {
      // output to file
      stream << "f ";
      for (auto face : vfaces) stream << soff + cvc + (2 * iphi) + face << " ";
      stream << '\n';
    }
    // close the loop
    stream << "f " << soff + cvc + (2 * iphi) + 1 << " "
           << soff + cvc + (2 * iphi) + 2 << " " << soff + cvc + 2 << " "
           << soff + cvc + 1 << '\n';
    // new line at the end of the line
    stream << '\n';
    ++iside;
  }
 
  // construct the sides at the end when all vertices are done
  Acts::Vector3 nvectorSide = transform.rotation().col(2);
  // write the normal vector @todo flip sides
  writeVTN(stream, vtnCounter, scalor, nvectorSide, "n");
  std::string ntphr = "//" + std::to_string(vtnCounter.ncounter);
 
  if (thickness != 0.) {
    // loop over the two sides
    for (iside = 0; iside < 2; ++iside) {
      // rest iphi
      size_t iphi = 0;
      for (; iphi < nSegments - 1; ++iphi) {
        stream << "f ";
        unsigned int base = cvc + (2 * iphi) + 1;
        stream << iside + base << ntphr << " ";
        stream << iside + base + 2 << ntphr << " ";
        stream << iside + base + (2 * nSegments) + 2 << ntphr << " ";
        stream << iside + base + (2 * nSegments) << ntphr << '\n';
      }
      // close the loop
      stream << "f ";
      stream << iside + cvc + (2 * iphi) + 1 << ntphr << " ";
      stream << iside + cvc + 1 << ntphr << " ";
      stream << iside + cvc + 1 + (2 * nSegments) << ntphr << " ";
      stream << iside + cvc + (2 * iphi) + 1 + (2 * nSegments) << ntphr << '\n';
    }
  }
}

writeVTN()

void ObjHelper::writeVTN	(	std::ofstream &	stream,
		VtnCounter &	vtnCounter,
		double	scalor,
		const Acts::Vector3 &	vertex,
		const std::string &	vtntype = "v",
		bool	point = false
	)

This will write a vertex to the fstream.

Parameters

stream	is the stream where to write to
vertex	is the vertex to be written out
cvertex	is the current vertex number

Definition at line 12 of file ObjHelper.cxx.

{
  // in case you make a point
  unsigned int cp = 0;
  // the counter
  if (vtntype == "v") {
    ++vtnCounter.vcounter;
    cp = vtnCounter.vcounter;
  } else if (vtntype == "t") {
    ++vtnCounter.vtcounter;
    cp = vtnCounter.vtcounter;
  } else if (vtntype == "n") {
    ++vtnCounter.ncounter;
    cp = vtnCounter.ncounter;
  } else
    return;
 
  // write out the vertex, texture vertex, normal
  stream << vtntype << " " << scalor * vertex.x() << " " << scalor * vertex.y()
         << " " << scalor * vertex.z() << '\n';
  // we create a point if needed
  if (point) stream << "p " << cp;
}