void Resample(PointVector& points, size_t n)
{
double I = PathLength(points) / (n - 1); // interval length
double D = 0.0;
PointVector newpoints;
newpoints.push_back(points[0]);
for (size_t i = 1; i < points.size(); ++i)
{
double d = Distance(points[i - 1], points[i]);
if ((D + d) >= I)
{
double qx = points[i - 1]->X + ((I - D) / d) * (points[i]->X - points[i - 1]->X);
double qy = points[i - 1]->Y + ((I - D) / d) * (points[i]->Y - points[i - 1]->Y);
PointPtr q(new Point(qx, qy));
newpoints.push_back(q);
points.insert(points.begin()+i,q);
D = 0.0;
}
else D += d;
}
// somtimes we fall a rounding-error short of adding the last point, so add it if so
if (newpoints.size() == n - 1)
{
newpoints.push_back(points[points.size() - 1]);
}
points.clear();
points.insert(points.begin(), newpoints.begin(), newpoints.end());
}
PointVector Track::getTrackTriangleStripPoints() const
{
PointVector vStripPoints;
if(m_vPathPoints.size() < 2)
{
return vStripPoints;
}
// First 2 points
NMVector2f v = getNormalizedPerpendicularVector(m_vPathPoints[1] - m_vPathPoints[0]) * m_fTrackWidth;
vStripPoints.push_back(m_vPathPoints[0] + v);
vStripPoints.push_back(m_vPathPoints[0] - v);
// All points in the middle
for(NLib::NSize_t i = 1; i < m_vPathPoints.size() - 1; ++i)
{
NMVector2f v1 = m_vPathPoints[i] - m_vPathPoints[i - 1];
NMVector2f v2 = m_vPathPoints[i + 1] - m_vPathPoints[i];
NMVector2f n = getNormalizedPerpendicularVector(v1 + v2) * m_fTrackWidth;
vStripPoints.push_back(m_vPathPoints[i] + n);
vStripPoints.push_back(m_vPathPoints[i] - n);
}
// Last 2 points
NLib::NSize_t uLastIndex = m_vPathPoints.size() - 1;
v = getNormalizedPerpendicularVector(m_vPathPoints[uLastIndex] - m_vPathPoints[uLastIndex - 1]) * m_fTrackWidth;
vStripPoints.push_back(m_vPathPoints[uLastIndex] + v);
vStripPoints.push_back(m_vPathPoints[uLastIndex] - v);
return vStripPoints;
}
void MouseMovementManager::mouseMove(QPointF const & pnt)
{
PointVector path = mPath.back();
mPath.pop_back();
path.push_back(pnt);
mPath.push_back(path);
recountCentre();
}
PointVector Space::leaveFromZone(const PointVector& vec, const Point& splitPoint, unsigned int d)
{
PointVector result;
PointVector::const_iterator iter = vec.begin();
PointVector::const_iterator endIter = vec.end();
for(;iter!=endIter;++iter)
{
if(iter->distanceXTo(splitPoint)<=d)
result.push_back(*iter);
}
return result;
}
void TranslateToOrigin(PointVector& points)
{
PointPtr c = Centroid(points);
PointVector newpoints;
for (size_t i = 0; i < points.size(); ++i)
{
double qx = points[i]->X - c->X;
double qy = points[i]->Y - c->Y;
newpoints.push_back(PointPtr(new Point(qx, qy)));
}
points.clear();
points.insert(points.begin(), newpoints.begin(), newpoints.end());
}
void ScaleToSquare(PointVector& points, double size)
{
RectanglePtr B = BoundingBox(points);
PointVector newpoints;
for (size_t i = 0; i < points.size(); ++i)
{
double qx = points[i]->X * (size / B->Width);
double qy = points[i]->Y * (size / B->Height);
newpoints.push_back(PointPtr(new Point(qx, qy)));
}
points.clear();
points.insert(points.begin(), newpoints.begin(), newpoints.end());
}
void fourier_broken(T &m, feature_t* buf) {
int dftCount = FDLENGTH;
typename ImageFactory<T>::view_type *tmp = simple_image_copy(m);
// get contour points for each CC
ImageList* ccs = cc_analysis(*tmp);
PointVector p;
for(ImageList::iterator cc_it = ccs->begin(); cc_it != ccs->end();
cc_it++) {
Cc* cc = static_cast<Cc*>(*cc_it);
Point orig = cc->origin();
PointVector* cc_p = contour_pavlidis(*cc);
for(PointVector::iterator p_it = cc_p->begin();
p_it != cc_p->end(); p_it++) {
p.push_back(*p_it + orig);
}
delete *cc_it;
delete cc_p;
}
delete ccs;
delete tmp->data();
delete tmp;
if (p.size() == 0) {
for (int k = 0; k < dftCount; k++)
buf[k] = 0.0;
return;
}
else if (p.size() == 1) {
buf[0] = 1.0;
for (int k = 1; k < dftCount; k++)
buf[k] = 0.0;
return;
}
// calculate convex hull and interpolate points
PointVector* hullPoints = convex_hull_from_points(&p);
FloatPointVector* interpolatedHullPoints =
interpolatePolygonPoints(hullPoints);
FloatVector* distances = minimumContourHullDistances(interpolatedHullPoints, &p);
floatFourierDescriptorBrokenA(interpolatedHullPoints, &p, distances, dftCount, buf);
delete hullPoints;
delete interpolatedHullPoints;
delete distances;
}
void RotateBy(PointVector& points, double theta)
{
PointPtr c = Centroid(points);
double cosine = cos(theta);
double sine = sin(theta);
PointVector newpoints;
for (size_t i = 0; i < points.size(); ++i)
{
double qx = (points[i]->X - c->X) * cosine - (points[i]->Y - c->Y) * sine + c->X;
double qy = (points[i]->X - c->X) * sine + (points[i]->Y - c->Y) * cosine + c->Y;
newpoints.push_back(PointPtr(new Point(qx, qy)));
}
points.clear();
points.insert(points.begin(), newpoints.begin(), newpoints.end());
}
int FilteredProcess::eliminate_triangle(const Triangle &triangle)
{
if (points_.size() != 2 * get_sensor_cnt())
return -1;
PointVector valid;
for (auto p : points_)
if (!triangle.is_inside(p))
valid.push_back(p);
if (valid.size() != get_sensor_cnt())
return -1;
points_ = valid;
return 0;
}
void auxdata::DrcPoly::motionDraw(const layprop::DrawProperties&, CtmQueue& transtack,
SGBitSet* plst) const
{
CTM trans = transtack.front();
PointVector* ptlist = DEBUG_NEW PointVector;
ptlist->reserve(_psize);
for (unsigned i = 0; i < _psize; i++)
{
ptlist->push_back( TP(_pdata[2*i], _pdata[2*i+1]) * trans);
}
glBegin(GL_LINE_LOOP);
for (unsigned i = 0; i < _psize; i++)
{
glVertex2i((*ptlist)[i].x(), (*ptlist)[i].y());
}
glEnd();
ptlist->clear();
delete ptlist;
}
inline PointVector* PointVector_from_python(PyObject* py) {
PyObject* seq = PySequence_Fast(py, "Argument must be an iterable of Points");
if (seq == NULL)
return 0;
int size = PySequence_Fast_GET_SIZE(seq);
PointVector* cpp = new PointVector();
try {
cpp->reserve(size);
for (int i = 0; i < size; ++i) {
PyObject* point = PySequence_Fast_GET_ITEM(seq, i);
Point p = coerce_Point(point);
cpp->push_back(p);
}
} catch (std::exception e) {
delete cpp;
Py_DECREF(seq);
PyErr_SetString(PyExc_RuntimeError, e.what());
return 0;
}
Py_DECREF(seq);
return cpp;
}
bool Whiteout::WhiteoutHelper(
bool viral,
Mask& mask,
unsigned int& depth,
PointVector& pv,
Point p)
{
// Perform the additional check. Note this is a virtual function.
if (AdditionalCheck(p))
{
// The check says this point is invalid.
return false;
}
// Get the point.
uint8_t* data = Point::GetDataByPoint(m_src, p);
if (data == 0)
{
// The point is outside the image.
return false;
}
// This will be on the stack. Bad, but no avoiding this.
Point point(0, 0);
// If any colour component is less that half intensity, it is considered a
// "dark" cell, and we will "white" it out.
if (data[0] < 0x7f || data[1] < 0x7f || data[2] < 0x7f)
{
// Maximum stack depth.
depth++;
if (depth > 100)
{
pv.push_back(p);
return false;
}
// Whiteout this cell.
data[0] = mask.GetBlue();
data[1] = mask.GetGreen();
data[2] = mask.GetRed();
// Point found callback (virtual).
PointFound(p);
if (viral)
{
// To the right.
point = Point(p.GetX()+1, p.GetY());
WhiteoutHelper(viral, mask, depth, pv, point);
// To the bottom.
point = Point(p.GetX(), p.GetY()+1);
WhiteoutHelper(viral, mask, depth, pv, point);
// To the left.
point = Point(p.GetX()-1, p.GetY());
WhiteoutHelper(viral, mask, depth, pv, point);
// To the top.
point = Point(p.GetX(), p.GetY()-1);
WhiteoutHelper(viral, mask, depth, pv, point);
}
return true;
}
return false;
}
