// Render scene
void display() {
glClear(GL_COLOR_BUFFER_BIT);
// Draw the points
pointSet();
// Swap front and back buffers
glfwSwapBuffers();
}
// -----------------------------------------------------------------------------
// CTestSDKStylusPopupMenu::TestSPMSetPositionTL
// -----------------------------------------------------------------------------
//
TInt CTestSDKStylusPopupMenu::TestSPMSetPositionTL( CStifItemParser& /*aItem*/ )
{
CTestSDKMenuObserver* observer = CTestSDKMenuObserver::NewL();
CleanupStack::PushL( observer );
STIF_ASSERT_NOT_NULL( observer );
TPoint point;
CAknStylusPopUpMenu* menu = CAknStylusPopUpMenu::NewLC( observer, point, NULL );
STIF_ASSERT_NOT_NULL( menu );
TPoint pointSet( KPoint, KPoint );
menu->SetPosition( pointSet, CAknStylusPopUpMenu::EPositionTypeRightTop );
CleanupStack::PopAndDestroy( menu );
CleanupStack::PopAndDestroy( observer );
return KErrNone;
}
/**
* create geometry for any list of 2D points
* @param drawType: [Input] An integer indicating how to connect points, such as osg::PrimitiveSet::LINE_LOOP
* @param pointVector: [Input] An vector contains 2D verteces
* @param color: [Input] Color of these primitives
* @return: A created OGS geometry
*/
osg::ref_ptr<osg::Geometry> AugmentationEnvironment::createPrimitiveGeometry(const int drawType, const vector<cv::Point2f>& pointVector, const osg::Vec4& color)
{
osg::ref_ptr<osg::Geometry> pointSet (new osg::Geometry());
osg::ref_ptr<osg::Vec3Array> vertices (new osg::Vec3Array());
osg::ref_ptr<osg::Vec4Array> overallColor = new osg::Vec4Array;
overallColor->push_back(color);
for (unsigned int j = 0 ; j < pointVector.size() ; j++)
{
vertices->push_back (osg::Vec3 ( pointVector[j].x, pointVector[j].y, 0.0));
}
pointSet->setVertexArray (vertices.get());
pointSet->addPrimitiveSet(new osg::DrawArrays(drawType,0,vertices->size()));
pointSet->setColorArray(overallColor.get());
pointSet->setColorBinding(osg::Geometry::BIND_OVERALL);
pointSet->getOrCreateStateSet()->setAttribute( new osg::Point( 3.0f ), osg::StateAttribute::ON );
return (pointSet.get());
}
// ax + by + cz = d; a^2 + b^2 + c^2 = 1;
void CalPlane(vector<Point3D>& cPointSet, GridMap &cgridmap)
{
int pointNum = cPointSet.size();
MatrixXf pointSet(pointNum,3);
Matrix3f A(3,3);
A<<0, 0, 0, 0, 0, 0, 0, 0, 0;
for(int i = 0; i < pointNum; i++)
{
pointSet(i,0) = cPointSet[i].X;
pointSet(i,1) = cPointSet[i].Y;
pointSet(i,2) = cPointSet[i].Z;
}
float xBar = pointSet.col(0).sum()/pointNum;
float yBar = pointSet.col(1).sum()/pointNum;
float zBar = pointSet.col(2).sum()/pointNum;
for(int i = 0; i < pointNum; i++)
{
A(0, 0) += (pointSet(i,0) - xBar)*(pointSet(i,0) - xBar);
A(0, 1) += (pointSet(i,0) - xBar)*(pointSet(i,1) - yBar);
A(0, 2) += (pointSet(i,0) - xBar)*(pointSet(i,2) - zBar);
A(1, 0) += (pointSet(i,1) - yBar)*(pointSet(i,0) - xBar);
A(1, 1) += (pointSet(i,1) - yBar)*(pointSet(i,1) - yBar);
A(1, 2) += (pointSet(i,1) - yBar)*(pointSet(i,2) - zBar);
A(2, 0) += (pointSet(i,2) - zBar)*(pointSet(i,0) - xBar);
A(2, 1) += (pointSet(i,2) - zBar)*(pointSet(i,1) - yBar);
A(2, 2) += (pointSet(i,2) - zBar)*(pointSet(i,2) - zBar);
}
EigenSolver<MatrixXf> es(A);
VectorXcf eigvals = es.eigenvalues();
Vector3f eigvalues;
eigvalues<<real(eigvals(0)), real(eigvals(1)), real(eigvals(2));
MatrixXcf eigvect = es.eigenvectors();
Matrix3f eigvectors;
eigvectors <<real(eigvect(0,0)), real(eigvect(0,1)), real(eigvect(0,2)), real(eigvect(1,0)), real(eigvect(1,1)), real(eigvect(1,2)),
real(eigvect(2,0)), real(eigvect(2,1)), real(eigvect(2,2));
float minValue = eigvalues(0);
int minNum = 0;
for(int i = 1; i < 3; i++)
{
if(eigvalues(i) < minValue)
{
minValue = eigvalues(i);
minNum = i;
}
}
float planePara[4] = {0, 0, 0, 0};
planePara[0] = eigvectors(0, minNum);
planePara[1] = eigvectors(1, minNum);
planePara[2] = eigvectors(2, minNum);
planePara[3] = planePara[0]*xBar + planePara[1]*yBar + planePara[2]*zBar;
if(planePara[0] < 0)
{
for(int i = 0; i < 4; i++)
{
cgridmap.planePara[i] = -planePara[i];
}
}
else
{
for(int i = 0; i < 4; i++)
{
cgridmap.planePara[i] = planePara[i];
}
}
float distance1 = 0;
float distance2 = sqrt(cgridmap.planePara[0]*cgridmap.planePara[0] + cgridmap.planePara[1]*cgridmap.planePara[1] + cgridmap.planePara[2]*cgridmap.planePara[2]);
for(int i = 0; i < pointNum; i++)
{
distance1 += fabs(cgridmap.planePara[0]*pointSet(i,0) + cgridmap.planePara[1]*pointSet(i,1) + cgridmap.planePara[2]*pointSet(i,2) - cgridmap.planePara[3]);
}
cgridmap.planeDegree = distance1/distance2/pointNum;
cgridmap.normalVector = acos(cgridmap.planePara[1]/distance2)/3.1415926*180;
}
GeometryPtr
Overlay::process(const Polyline2DPtr& p1, const Polyline2DPtr& p2)
{
if (!p1 || !p2 || p1->getPointListSize() < 2 || p2->getPointListSize() < 2) return GeometryPtr();
#ifdef WITH_CGAL
// Construct the first arrangement, containing a polyline 1.
Arrangement_2 arr1;
for (Point2Array::const_iterator it1 = p1->getPointList()->begin()+1; it1 != p1->getPointList()->end(); ++it1)
insert_non_intersecting_curve(arr1,toSegment(*(it1-1),*it1));
// to be a closed face, first and last point should be exactly the same.
// However we should not duplicate the same point twice at the end.
Vector2& fp1 = p1->getPointList()->getAt(0);
Vector2& lp1 = *(p1->getPointList()->end()-1);
if (fp1.x() != lp1.x() || fp1.y() != lp1.y())
insert_non_intersecting_curve(arr1,toSegment(lp1,fp1));
// std::cerr << arr1.number_of_vertices() << " " << arr1.number_of_edges() << " " << arr1.number_of_faces() << std::endl;
// Mark just the bounded face.
Arrangement_2::Face_iterator fit;
CGAL_assertion (arr1.number_of_faces() == 2);
for (fit = arr1.faces_begin(); fit != arr1.faces_end(); ++fit)
fit->set_data (fit != arr1.unbounded_face());
// Construct the second arrangement.
Arrangement_2 arr2;
for (Point2Array::const_iterator it2 = p2->getPointList()->begin()+1; it2 != p2->getPointList()->end(); ++it2)
insert(arr2,toSegment(*(it2-1),*it2));
// to be a closed face, first and last point should be exactly the same.
// However we should not duplicate the same point twice at the end.
Vector2& fp2 = p2->getPointList()->getAt(0);
Vector2& lp2 = *(p2->getPointList()->end()-1);
if (fp2.x() != lp2.x() || fp2.y() != lp2.y())
insert(arr2,toSegment(lp2,fp2));
// std::cerr << arr2.number_of_vertices() << " " << arr2.number_of_edges() << " " << arr2.number_of_faces() << std::endl;
CGAL_assertion (arr2.number_of_faces() == 2);
for (fit = arr2.faces_begin(); fit != arr2.faces_end(); ++fit)
fit->set_data (fit != arr2.unbounded_face());
// Compute the overlay of the two arrangements.
Arrangement_2 overlay_arr;
Overlay_traits overlay_traits;
overlay (arr1, arr2, overlay_arr, overlay_traits);
// std::cerr << overlay_arr.number_of_vertices() << " " << overlay_arr.number_of_edges() << " " << overlay_arr.number_of_faces() << std::endl;
// conversion between cgal structures and plantgl ones.
GeometryArrayPtr geomarray(new GeometryArray(0));
for (Arrangement_2::Face_iterator face = overlay_arr.faces_begin(); face != overlay_arr.faces_end(); ++face)
{
if (face->is_fictitious () || face->is_unbounded())
continue;
if (! face->data())
continue;
Arrangement_2::Ccb_halfedge_circulator curr = face->outer_ccb();
Point2ArrayPtr pointSet( new Point2Array(1,toVec2(curr->source()->point())));
do
{
pointSet->push_back(toVec2(curr->target()->point()));
++curr;
} while (curr != face->outer_ccb());
if (pointSet->size() == 1){
geomarray->push_back(GeometryPtr(new PointSet2D(pointSet)));
}
else if(pointSet->size() > 1){
geomarray->push_back(GeometryPtr(new Polyline2D(pointSet)));
}
}
if (geomarray->empty())return GeometryPtr();
else if (geomarray->size() == 1) return geomarray->getAt(0);
else return GeometryPtr(new Group(geomarray));
#else
#ifdef _MSC_VER
#pragma message("CGAL not included. Overlay routine will not work.")
#else
#warning "CGAL not included. Overlay routine will not work."
#endif
pglError("CGAL not included. Overlay routine will not work.");
return GeometryPtr();
#endif
}
