/**
* @brief Fills an array with the x,y coordinates for each Track segment.
* @details This class method is intended to be called by the OpenMOC
* Python "plotter" module as a utility to assist in plotting
* segments. Although this method appears to require two arguments,
* in reality it only requires one due to SWIG and would be called
* from within Python as follows:
*
* @code
* num_segments = track_generator.getNumSegments()
* coords = track_generator.retrieveSegmentCoords(num_segments*5)
* @endcode
*
* @param coords an array of coords of length 5 times the number of segments
* @param num_segments the total number of Track segments
*/
void TrackGenerator::retrieveSegmentCoords(double* coords, int num_segments) {
if (num_segments != 5*getNumSegments())
log_printf(ERROR, "Unable to retrieve the Track segment coordinates since "
"the TrackGenerator contains %d segments with %d coordinates "
"but an array of length %d was input",
getNumSegments(), 5*getNumSegments(), num_segments);
segment* curr_segment = NULL;
double x0, x1, y0, y1;
double phi;
segment* segments;
int counter = 0;
/* Loop over Track segments and populate array with their FSR ID and *
* start/end points */
for (int i=0; i < _num_azim; i++) {
for (int j=0; j < _num_tracks[i]; j++) {
x0 = _tracks[i][j].getStart()->getX();
y0 = _tracks[i][j].getStart()->getY();
phi = _tracks[i][j].getPhi();
segments = _tracks[i][j].getSegments();
for (int s=0; s < _tracks[i][j].getNumSegments(); s++) {
curr_segment = &segments[s];
coords[counter] = curr_segment->_region_id;
coords[counter+1] = x0;
coords[counter+2] = y0;
x1 = x0 + cos(phi) * curr_segment->_length;
y1 = y0 + sin(phi) * curr_segment->_length;
coords[counter+3] = x1;
coords[counter+4] = y1;
x0 = x1;
y0 = y1;
counter += 5;
}
}
}
return;
}
SplineTimeBase::TimeStatus SplineTimeBase::seek(SplineIterator& it) const
{
it.t = infinityMap(it.t);
int numSegments = getNumSegments();
//make sure we're always on a valid segment
if(it.seg < 0)
it.seg = 0;
if(it.seg >= numSegments)
it.seg = numSegments-1;
while(it.t >= times[it.seg+1])
{
if(it.seg == numSegments-1)
return After;
it.seg++;
}
while(it.t < times[it.seg])
{
if(it.seg == 0)
return Before;
it.seg--;
}
assert(it.t >= times[it.seg] && it.t < times[it.seg+1]);
return During;
}
MPI_Segment* MPI_ParticleStroke::allocateSegment( MPI_Point2D const &firstpoint, MPI_Point2D const &secondpoint )
{
float newsegposstart = getNumSegments();
float newsegposend = newsegposstart + 1.0;
return new MPI_ParticleSegment( getWorkspace(), *this, firstpoint, secondpoint, getOneSpace(), newsegposstart, newsegposend, getTrainElementFactory() );
}
VGint IPath::getParameteri( const VGint p ) const {
switch (p) {
case VG_PATH_FORMAT:
return getFormat();
case VG_PATH_DATATYPE:
return getDataType();
case VG_PATH_NUM_SEGMENTS:
return getNumSegments();
case VG_PATH_NUM_COORDS:
return getNumCoords();
default:
IContext::instance().setError( VG_ILLEGAL_ARGUMENT_ERROR );
return -1;
break;
}
}
void SplineCardinal<Point>::toHermite(SplineHermite<Point>& s) const
{
//copy times
s.copyTimeBase(*this);
s.getPoint(0)=getPoint(0);
int numSegments = getNumSegments();
if(numSegments > 0) {
s.getTangentOut(0)=(getPoint(1)-getPoint(0))*getTension(0);
for(int i=1;i<numSegments;i++) {
s.getPoint(i)=getPoint(i);
s.getTangentIn(i)=s.getTangentOut(i)=(getPoint(i+1)-getPoint(i-1))*getTension(i);
}
s.getTangentIn(numSegments)=(getPoint(numSegments)-getPoint(numSegments-1))*getTension(numSegments);
}
s.getTangentIn(0) = Zero;
s.getTangentOut(numSegments) = Zero;
}
//==============================================================================
std::size_t Spline::getNumWaypoints() const
{
return getNumSegments() + 1;
}
void PolyBezierCurve::generateSamplePoints( const curvedef::MapEvaluators & evalMap,
const int & rate )
{
assert( !evalMap.empty() );
mathdef::resize( m_samplePoints, rate * getNumSegments() + 1 );
mathdef::setZero( m_samplePoints );
// Evaluate the first point on the first curve, then
// Loop through all segment to sample 1st sample to last sample.
resetToFirstSegment();
int samp_i = 0; // Sample temp index
int j;
curvedef::Degree deg;
VectorX2s segCtrlPts;
while (m_iter != pointsEnd()) {
deg = getSegmentDegree( m_currentSegment );
const BezierEvaluator & evaluator = evalMap.find( deg )->second;
assert( evaluator.isBasesComputed() );
assert( deg > 0);
segCtrlPts = m_controlPoints.block( m_iter.getCurrentRow(), 0, deg + 1, 2 );
// Compute first end point if we are at first segment
if (m_currentSegment == 0)
{
j = 0;
// std::cout << "eval first t = " << computeParameterT(j, rate) << ": " << std::endl;
setSamplePoint(samp_i, evaluator.eval(segCtrlPts, j));
// std::cout << m_samplePoints.block(samp_i, 0, 1, 2) << std::endl;
++samp_i;
}
j = 1;
while (j <= rate)
{
// Sample segment point from index 1 to rate
// std::cout << "eval t = " << computeParameterT(j, rate) << ": " << std::endl;
setSamplePoint(samp_i, evaluator.eval(segCtrlPts, j));
// std::cout << m_samplePoints.block(samp_i, 0, 1, 2) << std::endl;
++samp_i;
++j;
}
advanceSegment();
}
//
// int segment = 0; // Segment index
// int samp_i = 0; // Sample temp index
// int ctrl_i = 0; // Control point temp index
// int j;
// curvedef::Degree deg; int numPts;
// VectorX2s segCtrlPts;
// while (segment < getNumSegments())
// {
// deg = getSegmentDegree( segment );
// const BezierEvaluator & evaluator = evalMap.find( deg )->second;
//
// assert( evaluator.isBasesComputed() );
// assert( deg > 0);
//
// std::cout << "CONTROL POINTS:\n" << m_controlPoints << std::endl;
// std::cout << "deg, ctrl_i, samp_i: " << deg << " " << ctrl_i << " " << samp_i << std::endl;
// std::cout << m_controlPoints.block( ctrl_i, 0, deg + 1, 2) << std::endl;
//
// segCtrlPts = m_controlPoints.block( ctrl_i, 0, deg + 1, 2);
//
// // Compute first end point if we are at first segment
// if (segment == 0)
// {
// j = 0;
// std::cout << "eval first t = " << computeParameterT(j, rate) << ": " << std::endl;
// setSamplePoint(samp_i, evaluator.eval(segCtrlPts, j));
// std::cout << m_samplePoints.block(samp_i, 0, 1, 2) << std::endl;
// ++samp_i;
// }
//
// j = 1;
// while (j <= rate)
// {
// // Sample segment point from index 1 to rate
// std::cout << "eval t = " << computeParameterT(j, rate) << ": " << std::endl;
// setSamplePoint(samp_i, evaluator.eval(segCtrlPts, j));
// std::cout << m_samplePoints.block(samp_i, 0, 1, 2) << std::endl;
// ++samp_i;
// ++j;
// }
//
// ctrl_i += deg;
// ++segment;
// }
}
