/*
* Returns an exact clone of the array.
*/
PointArray *copy() {
PointArray *clone = new PointArray(nElems);
for (int i = 0; i < nElems; i++) {
clone->append(thePoints[i]);
}
return clone;
}
static int SearchMaxAreaBoundary( const PointArray& bpts, const IntArray& bpos )
{
double maxArea = -1;
int pos = -1;
for( int i = 0; i < ( int )bpos.size(); i++ )
{
int s = 0;
for( int j = 0; j < i; j++ )
{
s += bpos[j];
}
int t = s + bpos[i];
PointArray polygon;
std::copy( bpts.begin() + s, bpts.begin() + t, std::back_inserter( polygon ) );
if( pos == -1 )
{
pos = i;
maxArea = PolygonArea( polygon );
}
else
{
double area = PolygonArea( polygon );
if( area > maxArea )
{
pos = i;
maxArea = area;
}
}
}
return pos;
}
void CurveFitter::splitCasteljau(const PointArray<256> &curve, qreal t,
PointArray<256> &left, PointArray<256> &right)
{
left.resize(curve.count());
right.resize(curve.count());
splitCasteljau(curve.count(), curve.data(), t, left.data(), right.data());
}
// 采用近似估计的算法
// 如果是闭合等值线，则搜索整个多边形中最长的边
// 如果是开放等值线，则搜索20%--80%范围内的多边形中最长边
void SearchLabelPostion( const PointArray& cnpts, DT_Point& tpt, double& angle )
{
if( cnpts.empty() ) return;
// 通常情况下，等值线至少有3个点
int s = 0, t = cnpts.size();
if( !IsPointEqual( cnpts.front(), cnpts.back() ) )
{
s = cnpts.size() / 5;
t = cnpts.size() - s;
}
int pos = s;
double maxDist = Distance_2( cnpts[0], cnpts[1] );
for( int i = s; i < t - 1; i++ )
{
double dist = Distance_2( cnpts[i], cnpts[i + 1] );
if( dist > maxDist )
{
pos = i;
maxDist = dist;
}
}
tpt = MidPoint( cnpts[pos], cnpts[pos + 1] );
angle = Direction( cnpts[pos], cnpts[pos + 1] );
}
Contour::Contour( const PointArray& pts, const EdgeArray& ea, const TriangleArray& ta )
{
// 将点数据复制一份
std::copy( pts.begin(), pts.end(), std::back_inserter( pa ) );
// 构造边和三角形属性数据
BuildAttribs( ea, ta, eaa, taa );
}
bool comp1(PointArray p1, PointArray p2) {
if (p1.getSize() != p2.getSize())
return false;
for (int i = 0; i < p1.getSize(); i++)
if (p1[i].getX() != p2[i].getX() || p1[i].getY() != p2[i].getY())
return false;
return true;
}
void OccupationMap::setOccupiedPoints(const PointArray &pointArray) {
if(pointArray.size() == 0) return;
PointArray tmp;
createDistinctPointArray(tmp, pointArray); // pointArray.size() >= 1 => tmp.size() >= 1
for(const CPoint *p = &tmp[0], *end = &tmp.last(); p <= end;) {
setOccupiedPoint(*(p++));
}
}
PointArray<256> CurveFitter::curve(const PointArray<256> &curvePoints, int count)
{
PointArray<256> points;
points.resize(count);
curve(curvePoints.count(), curvePoints.data(), count, points.data());
return points;
}
PointArray ShapeManager::makeRectanglePoints(int x, int y, int width, int height)
{
PointArray points;
points.push_back(Point(x, y));
points.push_back(Point(x + width, y));
points.push_back(Point(x + width, y + height));
points.push_back(Point(x, y + height));
return points;
}
static void GetOutMostBoundary( const PointArray& all_bpts, const IntArray& all_bpos, PointArray& bpts )
{
// 搜索最大边界(最外围边界)
int k = SearchMaxAreaBoundary( all_bpts, all_bpos );
if( k != -1 )
{
int ks = 0, kt = 0;
GetSEPos( all_bpos, k, ks, kt );
std::copy( all_bpts.begin() + ks, all_bpts.begin() + kt, std::back_inserter( bpts ) );
}
}
bool comp2(PointArray p1, PointArray p2) {
if (p1.getSize() != p2.getSize())
return false;
for (int i = 0; i < p1.getSize(); i++) {
bool a = false;
for (int j = 0; j < p1.getSize(); j++) {
if (p1[i].getX() == p2[j].getX() && p1[i].getY() == p2[j].getY())
a = true;
}
if (a == false) return a;
}
return true;
}
PointArray* PointArray::reverse() const
{
vector<Vector2*> *newArray = new vector<Vector2*>();
vector<Vector2*>::reverse_iterator iter;
Vector2 *point = nullptr;
for (iter = _controlPoints->rbegin(); iter != _controlPoints->rend(); ++iter)
{
point = *iter;
newArray->push_back(new Vector2(point->x, point->y));
}
PointArray *config = PointArray::create(0);
config->setControlPoints(newArray);
return config;
}
void OccupationMap::setOccupiedConnectedPoints(const PointArray &pointArray) {
if(pointArray.size() <= 1) return;
PointArray tmp;
createDistinctPointArray(tmp, pointArray); // pointArray.size() > 1 => tmp.size() >= 1
const CPoint *last = &tmp[0];
if(tmp.size() == 1) {
set(last->y, last->x, true);
} else {
const CPoint *end = &tmp.last();
for (const CPoint *next = last; next++ < end; last = next) {
setOccupiedLine(*last, *next);
}
}
}
PointArray* PointArray::clone() const
{
vector<Vector2*> *newArray = new vector<Vector2*>();
vector<Vector2*>::iterator iter;
for (iter = _controlPoints->begin(); iter != _controlPoints->end(); ++iter)
{
newArray->push_back(new Vector2((*iter)->x, (*iter)->y));
}
PointArray *points = new PointArray();
points->initWithCapacity(10);
points->setControlPoints(newArray);
points->autorelease();
return points;
}
static bool Save(const PointArray& PA, char* FileName) {
ofstream f(FileName);
f << "X\tY";
for(unsigned i = 0; i < PA.size(); ++i)
f << "\n" << PA[i].X << '\t' << PA[i].Y;
return false;
}
void write_classic_bundler(std::ofstream &file, CameraArray& cam_list, PointArray& point_list)
{
file << "# Bundle file v0.3" << std::endl;
file << cam_list.size() << " " << point_list.size() << std::endl;
write_cams(file, cam_list);
write_points(file, point_list);
}
PointArray::PointArray(const PointArray &pv) {
size = pv.getSize();
// could use size = pv.size since code in PointArray class has access to
// private variables
points = new Point[size];
for (int i = 0; i < size; ++i)
points[i] = pv.points[i];
}
PointArray shift(PointArray a, Point p)
{
for (size_t i=0; i!=a.size(); ++i) {
a[i].x += p.x;
a[i].y += p.y;
}
return a;
}
PointArray* PointArray::create(ssize_t capacity)
{
PointArray* pointArray = new PointArray();
if (pointArray)
{
if (pointArray->initWithCapacity(capacity))
{
pointArray->autorelease();
}
else
{
delete pointArray;
pointArray = nullptr;
}
}
return pointArray;
}
void SearchLabelPostion( const PointArray& cnpts, double tolerance, double width, LabelArray& la )
{
// 计算近似多边形
PointArray polygon;
ApproximatePolygon( cnpts, polygon, tolerance );
double c = 0.85;
// 在多边形上查找标注点
for( int i = 0; i < ( int )polygon.size() - 1; i++ )
{
DT_Point p1 = polygon[i], p2 = polygon[i + 1];
if( Distance( p1, p2 )*c > width )
{
DT_Label label = {MidPoint( p1, p2 ), Direction( p1, p2 )};
la.push_back( label );
}
}
}
void write_extended_bundler(std::ofstream &file, CameraArray& cam_list, PointArray& point_list, const std::vector<CameraConstraint>& constraints)
{
size_t nConstraints = constraints.size();
file << "# Extended Bundle file v0.1" << std::endl;
if (nConstraints > 0)
{
file << cam_list.size() << " " << point_list.size() << " " << nConstraints << std::endl;
}
else
{
file << cam_list.size() << " " << point_list.size() << std::endl;
}
write_constraints(file, constraints);
write_extended_cams(file, cam_list);
write_points(file, point_list);
}
IntVectorDataPtr enclosedPoints( const Box &bound )
{
typedef std::vector<typename T::Iterator> PointArray;
PointArray points;
m_tree->enclosedPoints( bound, std::back_insert_iterator<PointArray>( points ) );
IntVectorDataPtr indices = new IntVectorData();
indices->writable().reserve( points.size() );
for (typename PointArray::const_iterator it = points.begin(); it != points.end(); ++it)
{
indices->writable().push_back( std::distance( m_points->readable().begin(), *it ) );
}
return indices;
}
PointArray *MainScene::walkableAdjacentTilesCoordForTileCoord(const Point &tileCoord)
{
PointArray *tmp = PointArray::create(8);
Point p(tileCoord.x, tileCoord.y - 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
p.setPoint(tileCoord.x - 1, tileCoord.y);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
p.setPoint(tileCoord.x, tileCoord.y + 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
p.setPoint(tileCoord.x + 1, tileCoord.y);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
//
p.setPoint(tileCoord.x + 1, tileCoord.y + 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
p.setPoint(tileCoord.x + 1, tileCoord.y - 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
p.setPoint(tileCoord.x - 1, tileCoord.y - 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
p.setPoint(tileCoord.x - 1, tileCoord.y + 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
//
return tmp;
}
void flushPoints()
{
if (pointArray.count() == 0)
return;
SimpleColorShader &shader = shState->shaders().simpleColor;
shader.bind();
shader.setTranslation(Vec2i());
bindFBO();
pushSetViewport(shader);
glState.blendMode.pushSet(BlendNone);
pointArray.commit();
pointArray.draw();
pointArray.reset();
glState.blendMode.pop();
popViewport();
}
/*!
Search for findHomography
*/
void HuMoments::Create(const PointArray& pts, const DoubleArray& tangents)
{
ASSERT(!m_pPtsMat);
delete m_pPtsMat;
m_pPtsMat = new cv::Mat(pts.size(), 1,
cv::DataType<cv::Point2f>::type); //CV_64FC2 or CV_32FC2?
for (unsigned i = 0; i < pts.size(); ++i)
{
cv::Point2f& pt = m_pPtsMat->at<cv::Point2f>(i);
pt.x = (float)pts[i].x;
pt.y = (float)pts[i].y;
}
//Draw();
//DBG_PRINT1(m_pPtsMat->channels())
}
bool LayerAnimationStudy10::init()
{
if (!LayerColor::initWithColor(Color4B::WHITE))
{
return false;
}
Size winSize = Director::getInstance()->getWinSize();
Sprite* pItemSprite = Sprite::create("res/ui/coin.png");
pItemSprite->setPosition(100.0f,300.0f);
addChild(pItemSprite);
PointArray* pPtArray = PointArray::create(10);
pPtArray->addControlPoint(Vec2(winSize.width*0.5f, 50));
pPtArray->addControlPoint(Vec2(winSize.width-80.0f,120));
pPtArray->addControlPoint(Vec2(winSize.width-80,winSize.height-80));
pPtArray->addControlPoint(Vec2(50.0f,winSize.height-80));
pPtArray->addControlPoint(Vec2(50.0f, 120));
pPtArray->addControlPoint(Vec2(winSize.width*0.5f, 50));
int referenceCount = (int)pPtArray->getControlPoints()->size(); // 6个
for (int i=0; i<referenceCount; ++i)
{
Vec2 ptItem = pPtArray->getControlPointAtIndex(i);
createControlPoint(ptItem);
}
pItemSprite->setPosition(pPtArray->getControlPointAtIndex(0));
DrawNode* pDrawNode = DrawNode::create();
addChild(pDrawNode);
pDrawNode->drawCatmullRom(pPtArray, 100, Color4F::GREEN);
pDrawNode->setVisible(false);
TargetedAction* pTargetAction = TargetedAction::create(pItemSprite, CatmullRomTo::create(3.0f, pPtArray));
this->runAction(Sequence::create(DelayTime::create(1.0f), pTargetAction, nullptr));
return true;
}
OXPicture FX::gradient(const QPoint start, const QPoint stop,
const ColorArray &colors,
const PointArray &stops) {
XLinearGradient lg = {
{ start.x() << 16, start.y() << 16 },
{ stop.x() << 16, stop.y() << 16} };
QVarLengthArray<XRenderColor> cs(colors.size());
for (int i = 0; i < colors.size(); ++i)
setColor(cs[i], colors.at(i));
XFixed *stps;
if (stops.size() < 2) {
stps = new XFixed[2];
stps[0] = 0; stps[1] = (1<<16);
}
else {
int d = (1<<16);
stps = new XFixed[stops.size()];
for (int i = 0; i < stops.size(); ++i) {
if (stops.at(i) < 0) continue;
if (stops.at(i) > 1) break;
stps[i] = stops.at(i)*d;
}
}
XFlush (dpy);
OXPicture lgp = XRenderCreateLinearGradient(dpy, &lg, stps, &cs[0],
qMin(qMax(stops.size(),2),
colors.size()));
delete[] stps;
return lgp;
}
OXPicture FX::gradient(const QPoint c1, int r1, const QPoint c2, int r2,
const ColorArray &colors,
const PointArray &stops) {
XRadialGradient rg = {
{ c1.x() << 16, c1.y() << 16, r1 << 16 },
{ c2.x() << 16, c2.y() << 16, r2 << 16 } };
QVarLengthArray<XRenderColor> cs(colors.size());
for (int i = 0; i < colors.size(); ++i)
setColor(cs[i], colors.at(i));
XFixed *stps;
if (stops.size() < 2) {
stps = new XFixed[2];
stps[0] = 0; stps[1] = (1<<16);
}
else {
int d = ((int)(sqrt(pow(c2.x()-c1.x(),2)+pow(c2.y()-c1.y(),2)))) << 16;
stps = new XFixed[stops.size()];
for (int i = 0; i < stops.size(); ++i)
{
if (stops.at(i) < 0) continue;
if (stops.at(i) > 1) break;
stps[i] = stops.at(i)*d;
}
}
XFlush (dpy);
OXPicture lgp = XRenderCreateRadialGradient(dpy, &rg, stps, &cs[0],
qMin(qMax(stops.size(),2),
colors.size()));
delete[] stps;
return lgp;
}
void read_bundler_points(std::ifstream &file, unsigned int n_points, PointArray& point_list)
{
point_list.reserve(n_points);
for (unsigned int i = 0; i < n_points; ++i) {
double p0, p1, p2; // position
int r, g, b; // color;
unsigned int n_vis;
file >> p0 >> p1 >> p2;
file >> r >> g >> b;
file >> n_vis;
Point point;
read_visibility(file, n_vis, point.visibility_list);
point.position << p0, p1, p2;
point.color << r, g, b;
point_list.push_back(point);
}
}
IntVectorDataPtr nearestNeighbours(const typename T::Point &p, typename T::Point::BaseType r)
{
assert(m_tree);
typedef std::vector<typename T::Iterator> PointArray;
PointArray points;
unsigned int num = m_tree->nearestNeighbours(p, r, points);
IntVectorDataPtr indices = new IntVectorData();
indices->writable().reserve( num );
for (typename PointArray::const_iterator it = points.begin(); it != points.end(); ++it)
{
indices->writable().push_back( std::distance( m_points->readable().begin(), *it ) );
}
return indices;
}
