AntipoleNode* AntipoleTree::buildNewNode(float minimum_size, const MatchingThumbnails& old_matching)
{
MatchingThumbnails left_matching;
MatchingThumbnails right_matching;
std::vector<float> left_center;
std::vector<float> right_center;
if (old_matching.size() > minimum_size)
{
int status = divideMatching(old_matching, left_center, right_center, left_matching, right_matching);
if(status == 1)
{
AntipoleInternalNode* node = new AntipoleInternalNode(this);
QFuture<AntipoleNode*> left_future = QtConcurrent::run(this, &AntipoleTree::buildNewNode, minimum_size, left_matching);
QFuture<AntipoleNode*> right_future = QtConcurrent::run(this, &AntipoleTree::buildNewNode, minimum_size, right_matching);
AntipoleNode* left = left_future.result();
AntipoleNode* right = right_future.result();
node->setLeft(left);
computeCenter(left_center, left_matching);
left->setCenter(left_center);
left->setRadius(computeMaxRadius(left_center, left_matching));
node->setRight(right);
computeCenter(right_center, right_matching);
right->setCenter(right_center);
right->setRadius(computeMaxRadius(right_center, right_matching));
}
}
AntipoleLeaf* leaf = new AntipoleLeaf(this);
leaf->setMatching(old_matching);
return leaf;
}
void GestureRecognizer::setupPinchData(const NIXTouchEvent& event)
{
const NIXTouchPoint& first = event.touchPoints[0];
const NIXTouchPoint& second = event.touchPoints[1];
m_initialPinchDistance = computeDistance(WKPointMake(first.globalX, first.globalY), WKPointMake(second.globalX, second.globalY));
m_initialPinchScale = m_client->scale();
m_initialPinchContentCenter = computeCenter(WKPointMake(first.x, first.y), WKPointMake(second.x, second.y));
m_previousPinchGlobalCenter = computeCenter(WKPointMake(first.globalX, first.globalY), WKPointMake(second.globalX, second.globalY));
}
/** @brief computes best-fit approximations.
@param[in] points vector of points
@param[out] corners vector of the resulting corner points for drawing
*/
vector<Point3D>* computeBestFitPlane(const std::vector<Point3D>& points)
{
Matrix M(3, 3);
const Point3D center = computeCenter(points);
computeCovarianceMatrix3x3(points, M);
SVD::computeSymmetricEigenvectors(M);
const Point3D ev0(M(0, 0), M(1, 0), M(2, 0)); //first column of M == Eigenvector corresponding to the largest Eigenvalue == direction of biggest variance
const Point3D ev1(M(0, 1), M(1, 1), M(2, 1));
const Point3D ev2(M(0, 2), M(1, 2), M(2, 2)); //third column of M == Eigenvector corresponding to the smallest Eigenvalue == direction of lowest variance
//best-fit plane
std::cout << "*** Best-fit plane ***\n";
std::cout << "Point : " << center.x << ", " << center.y << ", " << center.z << std::endl;
std::cout << "Direction: " << ev2.x << ", " << ev2.y << ", " << ev2.z << std::endl;
//computing the mean distance to plane
double meanDistance = 0;
for (size_t i = 0; i < points.size(); ++i)
{
meanDistance += std::abs(distancePt2Plane(points[i], center, ev2)); // calculate mean distance from any point in the cloud to center point on plane
}
meanDistance /= points.size();
std::cout << "mean distance to plane: " << meanDistance << std::endl;
//set default values for distances (positive and negative largest value of double)
double mindist0 = +std::numeric_limits<double>::max();
double maxdist0 = -std::numeric_limits<double>::max();
double mindist1 = +std::numeric_limits<double>::max();
double maxdist1 = -std::numeric_limits<double>::max();
for (size_t i = 0; i < points.size(); ++i)
{
//compute new values for min- and maxdist0
const double dist0 = distancePt2Plane(points[i], center, ev0); // dist from i to center on plane with direction ev0 (biggest variance)
if (dist0 < mindist0) mindist0 = dist0;
if (dist0 > maxdist0) maxdist0 = dist0;
//compute new values for min- and maxdist1
const double dist1 = distancePt2Plane(points[i], center, ev1); // dist from i to center on plane with direction ev1 (mean variance)
if (dist1 < mindist1) mindist1 = dist1;
if (dist1 > maxdist1) maxdist1 = dist1;
}
vector<Point3D>* drawPoints = new vector<Point3D>();
// compute corner points of the bestFitPlane
Point3D corner1 = center + ev0*maxdist0 + ev1*maxdist1;
Point3D corner2 = center + ev0*maxdist0 + ev1*mindist1;
Point3D corner3 = center + ev0*mindist0 + ev1*mindist1;
Point3D corner4 = center + ev0*mindist0 + ev1*maxdist1;
drawPoints->push_back(corner1);
drawPoints->push_back(corner2);
drawPoints->push_back(corner3);
drawPoints->push_back(corner4);
return drawPoints;
}
void kmeans::startClustering() {
kcenter = new double[k];
for(int i = 0; i < k; i++) kcenter[i] = 0;
center = new average[k];
for(int i = 0; i < k; i++) {
center[i].setx(0);
center[i].sety(0);
}
imageArray = new int*[numRow];
for(int i = 0; i < numRow; ++i) {
imageArray[i] = new int[numCol];
}
for(int i = 0; i < numRow; i++) {
for(int j = 0; j < numCol; j++) {
imageArray[i][j] = 0;
}
}
labelChecker = true;
while (labelChecker) {
labelChecker = false;
computeCenter();
computeDistance();
}
listHead.putonImage(imageArray);
}
ReturnFlag CPSOSubSwarm::evolve(){
if(this->m_popsize<1) return Return_Normal;
Solution<CodeVReal> t;
ReturnFlag r_flag=Return_Normal;
for(int i=0;i<this->m_popsize;i++){
t=this->m_pop[i]->self();
bool flag=false;
r_flag=this->m_pop[i]->moveBound(this->m_pop[i]->m_pbest,this->getNearestBest(this->m_pop[i]->self()),m_W,m_C1,m_C2);//
if(this->m_pop[i]->self()>this->m_pop[i]->m_pbest){
this->m_pop[i]->m_pbest=this->m_pop[i]->self();
flag=this->updateBestArchive(this->m_pop[i]->self());
}
if(r_flag!=Return_Normal) break;
if(!flag&&this->m_pop[i]->self()>t){
r_flag=updateBest(i,1.0);
}
if(r_flag!=Return_Normal) { break;}
}
if(r_flag==Return_Normal){
this->m_evoNum++;
double ratio=Global::msp_global->mp_problem->getEvaluations()%CAST_PROBLEM_DYN->getChangeFre()/static_cast<double>(CAST_PROBLEM_DYN->getChangeFre());
m_W=m_maxW-(m_maxW-m_minW)*ratio;
}
computeCenter();
updateCurRadius(true);
return r_flag;
}
void imKMeans(const cv::Mat& src, cv::Mat& dst) {
cv::Mat res = src.clone();
std::vector<uchar> centers[3];
std::vector<cv::Point2i> groups[3] = {
{cv::Point2i(0, 0)},
{cv::Point2i(4, 0)},
{cv::Point2i(8, 0)},
};
for (int i = 0; i < 3; i++) {
centers[i] = computeCenter(src, groups[i]);
// std::cout << "Initial groups: " << groups[i] << "\n";
}
for (int i = 0; i < src.rows/2; i+=4) {
for (int j = 0; j < src.cols; j+=4) {
if (i == 0 && j <= 8) {
continue;
}
cv::Point2i loc(j, i);
// std::cout << loc << "\n";
double minDist = std::numeric_limits<double>::max();
int nearest = 0;
for (int k = 0; k < 3; k++) {
double dist = euclidDistance(src, loc, centers[k], 4);
if (dist < minDist) {
minDist = dist;
nearest = k;
}
}
groups[nearest].push_back(loc);
// std::cout << "Updated group " << nearest << " " << groups[nearest] << std::endl;
centers[nearest] = computeCenter(src, groups[nearest]);
switch(nearest) {
case 0:
maskFill(res, j, i, 4, 0);
break;
case 1:
maskFill(res, j, i, 4, 128);
break;
case 2:
maskFill(res, j, i, 4, 255);
break;
}
}
}
dst = res;
}
void Mesh::ReadMesh(istream& strm, int camNums)
{
int vertex_numbers, face_numbers, Joint_number, weights_number;
strm>>vertex_numbers>>face_numbers>>Joint_number>>weights_number;
// vertexes and weights
double x,y,z;
vertices.resize(vertex_numbers);
for(int i=0;i<vertex_numbers;i++) {
strm>>x>>y>>z;
vertices[i].pos = Vector3f(x,y,z);
vertices[i].weight.resize(Joint_number+1,.0);
for(int j=0;j<weights_number;j++) {
int index;
double w;
strm>>index>>w;
vertices[i].weight[index] = w;
}
// color
vertices[i].color[0] = 0.f;
vertices[i].color[1] = 0.f;
vertices[i].color[2] = 0.f;
vertices[i].texture.resize(camNums*20);
}
// faces
int index_v1,index_v2,index_v3;
for(int i=0;i<face_numbers;i++) {
int first = (int)edges.size();
strm>>index_v1>>index_v2>>index_v3;
edges.resize(edges.size() + 3);
edges[first + 0].vertex = index_v1;
edges[first + 1].vertex = index_v2;
edges[first + 2].vertex = index_v3;
edges[first + 0].prev = index_v3;
edges[first + 1].prev = index_v1;
edges[first + 2].prev = index_v2;
vertices[index_v1].edges.push_back(first);
vertices[index_v2].edges.push_back(first);
vertices[index_v3].edges.push_back(first);
}
//skeleton
skeleton.resize(Joint_number);
for(int i=0;i<Joint_number;i++)
strm>>skeleton[i].curr>>skeleton[i].norm[0]>>skeleton[i].norm[1]>>skeleton[i].norm[2]>>
skeleton[i].pos[0]>>skeleton[i].pos[1]>>skeleton[i].pos[2]>>skeleton[i].prev;
computeCenter();
computeBBox();
return;
}
void ConfigStat::compute() {
deleteComputation();
initComputation();
computeDistanceMatrix();
computeCenter();
computeCentroid();
computeBetweennessCenter();
}
void StarShape::setSize(const QSizeF &newSize)
{
QTransform matrix(resizeMatrix(newSize));
m_zoomX *= matrix.m11();
m_zoomY *= matrix.m22();
// this transforms the handles
KoParameterShape::setSize(newSize);
m_center = computeCenter();
}
void KoStarShape::updatePath( const QSizeF &size )
{
Q_UNUSED(size);
qreal radianStep = M_PI / static_cast<qreal>(m_cornerCount);
createPoints( m_convex ? m_cornerCount : 2*m_cornerCount );
KoSubpath &points = *m_subpaths[0];
uint index = 0;
for( uint i = 0; i < 2*m_cornerCount; ++i )
{
uint cornerType = i % 2;
if( cornerType == base && m_convex )
continue;
qreal radian = static_cast<qreal>( (i+1)*radianStep ) + m_angles[cornerType];
QPointF cornerPoint = QPointF( m_zoomX * m_radius[cornerType] * cos( radian ), m_zoomY * m_radius[cornerType] * sin( radian ) );
points[index]->setPoint( m_center + cornerPoint );
points[index]->unsetProperty( KoPathPoint::StopSubpath );
points[index]->unsetProperty( KoPathPoint::CloseSubpath );
if( m_roundness[cornerType] > 1e-10 || m_roundness[cornerType] < -1e-10 )
{
// normalized cross product to compute tangential vector for handle point
QPointF tangentVector( cornerPoint.y()/m_radius[cornerType], -cornerPoint.x()/m_radius[cornerType] );
points[index]->setControlPoint2( points[index]->point() - m_roundness[cornerType] * tangentVector );
points[index]->setControlPoint1( points[index]->point() + m_roundness[cornerType] * tangentVector );
}
else
{
points[index]->removeControlPoint1();
points[index]->removeControlPoint2();
}
index++;
}
// first path starts and closes path
points[0]->setProperty( KoPathPoint::StartSubpath );
points[0]->setProperty( KoPathPoint::CloseSubpath );
// last point stops and closes path
points.last()->setProperty( KoPathPoint::StopSubpath );
points.last()->setProperty( KoPathPoint::CloseSubpath );
normalize();
m_handles.clear();
m_handles.push_back( points.at(tip)->point() );
if( ! m_convex )
m_handles.push_back( points.at(base)->point() );
m_center = computeCenter();
}
void Mesh::ReadOff(istream& strm,int camNums)
{
string tmp;
strm>>tmp;
/*if(strcmp(tmp.c_str(),"COFF"));
{
cout<<".off file has been wrong, please check your file!"<<endl;
return;
}*/
int vertex_numbers, face_numbers, tmp_number;
strm>>vertex_numbers>>face_numbers>>tmp_number;
double x,y,z;
float r,g,b,a;
for(int i=0;i<vertex_numbers;i++)
{
strm>>x>>y>>z>>r>>g>>b>>a;
vertices.resize(vertices.size() + 1);
vertices.back().pos = Vector3f(x,y,z);
vertices.back().color = Vector3f(r,g,b);
vertices[i].texture.resize(camNums*20);
}
int index_v1,index_v2,index_v3;
for(int i=0;i<face_numbers;i++)
{
int first = (int)edges.size();
strm>>tmp_number>>index_v1>>index_v2>>index_v3;
edges.resize(edges.size() + 3);
edges[first + 0].vertex = index_v1;
edges[first + 1].vertex = index_v2;
edges[first + 2].vertex = index_v3;
edges[first + 0].prev = index_v3;
edges[first + 1].prev = index_v1;
edges[first + 2].prev = index_v2;
vertices[index_v1].edges.push_back(first);
vertices[index_v2].edges.push_back(first);
vertices[index_v3].edges.push_back(first);
}
skeleton.clear();
computeCenter();
computeBBox();
return;
}
/** @brief computes best-fit approximations.
@param[in] points vector of points
@param[out] corners vector of the resulting corner/end points for drawing
*/
vector<Point3D>* computeBestFitLine(const std::vector<Point3D>& points)
{
Matrix M(3, 3);
const Point3D center = computeCenter(points);
computeCovarianceMatrix3x3(points, M);
SVD::computeSymmetricEigenvectors(M);
const Point3D ev0(M(0, 0), M(1, 0), M(2, 0)); //first column of M == Eigenvector corresponding to the largest Eigenvalue == direction of biggest variance
const Point3D ev1(M(0, 1), M(1, 1), M(2, 1));
const Point3D ev2(M(0, 2), M(1, 2), M(2, 2)); //third column of M == Eigenvector corresponding to the smallest Eigenvalue == direction of lowest variance
//best-fit line
std::cout << "*** Best-fit line ***\n";
std::cout << "Point : " << center.x << ", " << center.y << ", " << center.z << std::endl;
std::cout << "Direction: " << ev0.x << ", " << ev0.y << ", " << ev0.z << std::endl;
//computing the mean distance to line
double meanDistance = 0;
for (size_t i = 0; i < points.size(); ++i)
{
meanDistance += distancePt2Line(points[i], center, ev0);
}
meanDistance /= points.size();
std::cout << "mean distance to line: " << meanDistance << std::endl;
//Compute the end points of the line
double mindist = +std::numeric_limits<double>::max();
double maxdist = -std::numeric_limits<double>::max();
for (size_t i = 0; i < points.size(); ++i)
{
//compute distance for each point
const double dist = distancePt2Plane(points[i], center, ev0);
if (dist < mindist) mindist = dist;
if (dist > maxdist) maxdist = dist;
}
vector<Point3D>* drawPoints = new vector<Point3D>();
//compute new corner points
Point3D corner1 = center + ev0*mindist;
Point3D corner2 = center + ev0*maxdist;
drawPoints->push_back(corner1);
drawPoints->push_back(corner2);
return drawPoints;
}
void GestureRecognizer::updatePinchData(double timestamp, const NIXTouchEvent& event)
{
assert(m_initialPinchScale > 0);
const NIXTouchPoint& first = event.touchPoints[0];
const NIXTouchPoint& second = event.touchPoints[1];
WKPoint currentCenter = computeCenter(WKPointMake(first.globalX, first.globalY), WKPointMake(second.globalX, second.globalY));
WKPoint delta = WKPointMake((currentCenter.x - m_previousPinchGlobalCenter.x) / m_client->scale(),
(currentCenter.y - m_previousPinchGlobalCenter.y) / m_client->scale());
double currentDistance = computeDistance(WKPointMake(first.globalX, first.globalY), WKPointMake(second.globalX, second.globalY));
double newScale = m_initialPinchScale * (currentDistance / m_initialPinchDistance);
m_client->handlePinch(timestamp, delta, newScale, m_initialPinchContentCenter);
m_previousPinchGlobalCenter = currentCenter;
}
void computeCoarianceMatrix(const std::vector<Point3D> &points, Matrix &M) {
M.resize(3, 3);
const ptrdiff_t N(points.size());
if (N < 1) return;
//compute the mean value (center) of the points cloud
Point3D mean = computeCenter(points);
//Compute the entries of the (symmetric) covariance matrix
double Mxx(0), Mxy(0), Mxz(0), Myy(0), Myz(0), Mzz(0);
#pragma omp parallel for reduction(+: Mxx,Mxy,Mxz,Myy,Myz,Mzz) //omp reduction enables parallel sum up of values
for (ptrdiff_t i = 0; i < N; ++i) {
const Point3D &pt = points[i];
//generate mean-free coorinates
const double x1(pt.x - mean.x);
const double y1(pt.y - mean.y);
const double z1(pt.z - mean.z);
//Sum up the entries for the covariance matrix
Mxx += x1 * x1;
Mxy += x1 * y1;
Mxz += x1 * z1;
Myy += y1 * y1;
Myz += y1 * z1;
Mzz += z1 * z1;
}
//setting the sums to the matrix (division by N just for numerical reason if we have very large sums)
M(0, 0) = Mxx / N;
M(0, 1) = Mxy / N;
M(0, 2) = Mxz / N;
M(1, 0) = M(0, 1);
M(1, 1) = Myy / N;
M(1, 2) = Myz / N;
M(2, 0) = M(0, 2);
M(2, 1) = M(1, 2);
M(2, 2) = Mzz / N;
for(int i=0; i<9; ++i)
printf("%lf\n",M[i] );
}
/******************************************************************//**
* Initializing protein class
******************************************************************/
CProtein::CProtein(const char *fname) {
vector<AA> aas;
string ss = fname;
if (ss.find("pdb") != std::string::npos) {
CPDB::loadFromPDB(fname, aas);
} else if (ss.find("pqr") != std::string::npos) {
CPDB::loadFromPQR(fname, aas);
}
// Add each atom in each amino acid of protein to matrix of atoms
for (int i = 0; i < aas.size(); i++)
for (int j = 0; j < aas[i].getNumAtoms(); j++)
m_atoms.push_back(aas[i][j]);
// Add charge on atom in each amino acid to vector of charges
for (int i = 0; i < m_atoms.size(); i++) {
if (m_atoms[i].getCharge() != 0.0)
m_chargedAtoms.push_back(&(m_atoms[i]));
}
m_center = computeCenter(); // compute center of geometry if the atom
// reposition each atom WRT to the center of mass of protein
for (int i = 0; i < m_atoms.size(); i++)
m_atoms[i].setPos(m_atoms[i].getPos() - m_center);
computeRadius();
m_sumCharge = 0.0; // Total charge of protein
for (int i = 0; i < getNumCharges(); i++) m_sumCharge += getCharge(i);
REAL s = 0.0; // Total charge of protein to print as output
for (int i = 0; i < getNumCharges(); i++) s += (getCharge(i));
cout << "sum = " << s << " rad = " << m_rad << endl;
// Creating a multipole expansion class for the protein
m_mpe = new CMPE(*this);
m_exps.push_back(m_mpe); // Pushing the MPE to an array
// Adding the protein center to an array of centers
m_cens.push_back(&m_center);
m_mols.push_back(this); // Adding the protein to an array of proteins
}
ReturnFlag NFishSwarm::evolve(){
ReturnFlag rf=Return_Normal;
//new prey behavior
for(auto &fish:m_pop){
for(int i=0;i<m_tryNumber;++i){
rf=fish->prey(m_visual);
if(rf!=Return_Normal) return rf;
updateBestArchive(fish->self());
}
}
//new follow behavior
for(auto &fish:m_pop){
rf=fish->follow(*m_best[0],m_visual);
if(rf!=Return_Normal) return rf;
updateBestArchive(fish->self());
}
//new swarm behevior
computeCenter();
findBest();
for(auto &fish:m_pop){
if(m_center>fish->self()){
if(fish->m_index!=m_bestIdx[0]){
rf=fish->swarm(m_center,m_visual);
if(rf!=Return_Normal) return rf;
}else{
fish->self()=m_center;
}
updateBestArchive(fish->self());
}
}
updateVisual();
updateCurRadius();
m_iter++;
return rf;
}
int main(int argc, char *argv[]) {
// Check command arguments
int c;
int DEVICE, SEGMENTATION_RATIO, OFFSET, ANGLE, THRESHOLD, RESOLUTION;
while ((c = getopt(argc, argv, "v:s:o:a:t:r:")) != -1) {
switch (c) {
case 'v':
DEVICE = atoi(optarg);
break;
case 's':
SEGMENTATION_RATIO = atoi(optarg);
break;
case 'o':
OFFSET = atoi(optarg);
break;
case 'a':
ANGLE = atoi(optarg);
break;
case 't':
THRESHOLD = atoi(optarg);
break;
case 'r':
RESOLUTION = atoi(optarg);
break;
default: // '?'
std::cout << "Usage: " << argv[0] << " [-v device] [-s segmentation_ratio] [-o offset] [-a angle] [-t threshold] [-r resolution]" << std::endl;
return -1;
}
}
if (argc != 13) {
std::cout << "Usage: " << argv[0] << " [-v device] [-s segmentation_ratio] [-o offset] [-a angle] [-t threshold] [-r resolution]" << std::endl;
return -1;
}
/*ROS*/
r_init( Road_Detecter);
r_hdlr( hdl);
r_newPub( pubRoad, hdl, challenge1::road, Road, 1000);
ros::Rate loop_rate(10);
challenge1::road rd;
/**/
cv::VideoCapture myVideoCapture(DEVICE);
if (!myVideoCapture.isOpened()) {
std::cout << "ERROR: Cannot open device " << DEVICE << std::endl;
return -1;
}
cv::namedWindow("Video Captured");
cv::namedWindow("Road Detected");
int imgCenter = myVideoCapture.get(CV_CAP_PROP_FRAME_WIDTH) / 2;
int preCenter = imgCenter;
int movingDirection = GO_STRAIGHT;
//while (1) {
while( ros::ok()){
int key = cv::waitKey(1);
if ((key & 0xFF) == 27) // 'Esc' key
return 0;
cv::Mat inputFrame, segmentedInputFrame;
myVideoCapture >> inputFrame;
inputFrame(cv::Range(inputFrame.rows - inputFrame.rows / SEGMENTATION_RATIO, inputFrame.rows - 1), cv::Range::all()).copyTo(segmentedInputFrame);
// Detect road. In general, there are only vertical lines
cv::Mat road = detectRoad(segmentedInputFrame, OFFSET, ANGLE);
// Compute the road center
int curCenter = computeCenter(road);
// Compute the moving direction
movingDirection = computeMovingDirection(imgCenter, preCenter, curCenter, movingDirection, THRESHOLD, RESOLUTION);
std::cout << movingDirection << std::endl;
cv::imshow("Video Captured", segmentedInputFrame);
cv::imshow("Road Detected", road);
/*ROS*/
/*switch( movingDirection){
case GO_STRAIGHT:
case TURN_LEFT:
case TURN_RIGHT:
default:
break;
}*/
rd.direction = movingDirection;
pubRoad.publish( rd);
ros::spinOnce();
loop_rate.sleep();
/*\ROS*/
}
return 0;
}
void BoundingPolyhedron::addPoint(Vec3f *point) {
points.push_back(point);
computeCenter();
}
/** @brief computes best-fit approximations.
@param points vector of points
*/
vector<Point3D>* computeBestFits(const std::vector<Point3D> &points) {
Matrix M(3, 3);
const Point3D center = computeCenter(points);
computeCovarianceMatrix3x3(points, M);
SVD::computeSymmetricEigenvectors(M);
const Point3D ev0(M(0, 0), M(1, 0), M(2,
0)); //first column of M == Eigenvector corresponding to the largest Eigenvalue == direction of biggest variance
const Point3D ev1(M(0, 1), M(1, 1), M(2, 1));
const Point3D ev2(M(0, 2), M(1, 2), M(2,
2)); //third column of M == Eigenvector corresponding to the smallest Eigenvalue == direction of lowest variance
//best-fit line
std::cout << "*** Best-fit line ***\n";
std::cout << "Point : " << center.x << ", " << center.y << ", " << center.z << std::endl;
std::cout << "Direction: " << ev0.x << ", " << ev0.y << ", " << ev0.z << std::endl;
//computing the mean distance to line
double meanDistance = 0;
for (size_t i = 0; i < points.size(); ++i) {
meanDistance += distancePt2Line(points[i], center, ev0);
}
meanDistance /= points.size();
std::cout << "mean distance to line: " << meanDistance << std::endl;
std::cout << "\n";
//best-fit plane
std::cout << "*** Best-fit plane ***\n";
std::cout << "Point : " << center.x << ", " << center.y << ", " << center.z << std::endl;
std::cout << "Direction: " << ev2.x << ", " << ev2.y << ", " << ev2.z << std::endl;
//computing the mean distance to line
meanDistance = 0;
for (size_t i = 0; i < points.size(); ++i) {
meanDistance += std::abs(distancePt2Plane(points[i], center, ev2));
}
meanDistance /= points.size();
std::cout << "mean distance to plane: " << meanDistance << std::endl;
double param = .1;
double param2 = 1.0;
//We just calculate midlepoint
Point3D* midlepoint1;
Point3D* midlepoint2;
midlepoint1 = midpoint2(center - ev1*param,center - ev0*param);
midlepoint2 = midpoint2(center + ev1*param,center + ev0*param);
vector<Point3D>* drawPoints = new vector<Point3D>();
/*
drawPoints->push_back(center + ev1*param);
drawPoints->push_back(center - ev1*param);
drawPoints->push_back(center + ev0*param);
drawPoints->push_back(center - ev0*param);
*/
///////////////////////////////////////
Point3D midlepoint11;
Point3D midlepoint22;
midlepoint11.x = midlepoint1->x;
midlepoint11.y = midlepoint1->y;
midlepoint11.z = midlepoint1->z;
midlepoint22.x = midlepoint2->x;
midlepoint22.y = midlepoint2->y;
midlepoint22.z = midlepoint2->z;
///////////////////////////////////////
drawPoints->push_back(center-(center + ev2*param));
drawPoints->push_back(center+(center + ev2*param));
drawPoints->push_back(center-(center + ev0*param));
drawPoints->push_back(center+(center + ev0*param));
//drawPoints->push_back(center + ev2*param);
//drawPoints->push_back(center - ev2*param);
return drawPoints;
}
