void Ctr2SufManager::CheckCCW() { int iTotal=0; for( int i = 0; i < this->mesh->suffacenum; i ++) { if (this->mesh->sufmat[i*2]==1) { int temp=this->mesh->sufface[3*i+0]; this->mesh->sufface[3*i+0]=this->mesh->sufface[3*i+1]; this->mesh->sufface[3*i+1]=temp; iTotal++; } } DBWindowWrite("%d triangles permuted when checking ccw\n",iTotal); return; }
void CMeshEditing::Convert2DProfileTo3D() { if (this->UserInput2DProfile.empty()) { return; } //judge the type of curve: open/closed according to the distance of the first and last point //get the average length double dTotalLen=0; for (unsigned int i=0;i<this->UserInput2DProfile.size()-1;i++) { Point_2 CurrentPoint(this->UserInput2DProfile.at(i).x,this->UserInput2DProfile.at(i).y); Point_2 NextPoint(this->UserInput2DProfile.at(i+1).x,this->UserInput2DProfile.at(i+1).y); dTotalLen=dTotalLen+sqrt(CGAL::squared_distance(CurrentPoint,NextPoint)); } double dAverageLen=dTotalLen/(double)(this->UserInput2DProfile.size()-1); //get length between the first and last point Point_2 FirstPoint(this->UserInput2DProfile.front().x,this->UserInput2DProfile.front().y); Point_2 FinalPoint(this->UserInput2DProfile.back().x,this->UserInput2DProfile.back().y); double dFinalLen=sqrt(CGAL::squared_distance(FirstPoint,FinalPoint)); //judge if (dFinalLen>dAverageLen*3)//open curve { CKWResearchWorkView* pView=(CKWResearchWorkView*)this->pDoc->GetView(RUNTIME_CLASS(CKWResearchWorkView)); GLdouble* modelview=pView->GetModelview(); GLdouble* projection=pView->GetProjection(); GLint* viewport=pView->GetViewport(); Point_3 StartPoint,EndPoint; Facet_handle FhPaintFacet; CPaintingOnMesh Painting; bool bResultStart=Painting.PaintingScrPointOnFrontalMesh(pDoc->GetMesh(),this->UserInput2DProfile.front(),StartPoint, FhPaintFacet,modelview,projection,viewport); bool bResultEnd=Painting.PaintingScrPointOnFrontalMesh(pDoc->GetMesh(),this->UserInput2DProfile.back(),EndPoint, FhPaintFacet,modelview,projection,viewport); if (bResultStart&&bResultEnd)//two points on mesh,deformation { DBWindowWrite("Deformation Handle Curve...\n"); pDoc->GetMeshDeformation().SetDrawingCurveType(DEFORMATION_HANDLE_CURVE);//handle curve, if more than one point pDoc->GetMeshDeformation().SetCurvePoint2D(this->UserInput2DProfile); pDoc->GetMeshDeformation().Conver2DCurveTo3D(pDoc->GetMesh()); pDoc->OnModeDeformation(); } else if (!bResultStart && !bResultEnd)//two points not on mesh,cutting { DBWindowWrite("Cutting Curve...\n"); pDoc->GetMeshCutting().SetDrawingCurveType(CUTTING_ACROSS_CURVE); pDoc->GetMeshCutting().SetCurvePoint2D(this->UserInput2DProfile); pDoc->GetMeshCutting().Conver2DCurveTo3D(pDoc->GetMesh()); pDoc->OnModeCutting(); } else { AfxMessageBox("Invalid Input!"); } } else//closed curve { DBWindowWrite("Extrusion Curve...\n"); pDoc->GetMeshExtrusion().SetDrawingCurveType(EXTRUSION_CLOSED_CURVE); pDoc->GetMeshExtrusion().SetCurvePoint2D(this->UserInput2DProfile); pDoc->GetMeshExtrusion().Conver2DCurveTo3D(pDoc->GetMesh()); pDoc->OnModeExtrusion(); } this->UserInput2DProfile.clear(); }
void Ctr2SufManager::ctr2sufProc(vector<vector<Point_3> >& MeshBoundingProfile3D,vector<Point_3>& vecTestPoint) { clock_t start = clock(); struct __timeb64 timebuffer; char *timeline; _ftime64( &timebuffer ); timeline = _ctime64( & ( timebuffer.time ) ); printf( "The time is %.19s.%hu %s", timeline, timebuffer.millitm, &timeline[20] ); //common line case //compute the common line if( isComnCase ) { float tempparam[ 8 ]; for( int i = 0; i < 8; i ++) { tempparam[ i ] = pparam[ i ]; } ////////////////////////////////////////////////////////////////////////// /*for( int i = 0 ; i < 8; i ++ ) { cout<<tempparam[ i ]<<","; } cout<<endl;*/ ////////////////////////////////////////////////////////////////////////// computeComnLine( tempparam, tempparam + 4, comndir, comnpt); ////////////////////////////////////////////////////////////////////////// /*for( int i = 0 ; i < 8; i ++ ) { cout<<tempparam[ i ]<<","; } cout<<endl;*/ ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// //writeComnLineDB( tempparam, tempparam + 4, comndir, comnpt); ////////////////////////////////////////////////////////////////////////// } ////////////////////////////////////////////////////////////////////////// /*for( int i = 0; i < planenum + 4; i ++ ) { cout<<pparam[ 4* i ]<<"," <<pparam[ 4*i + 1]<<"," <<pparam[ 4*i + 2]<<"," <<pparam[ 4*i + 3]<<endl; } cout<<endl;*/ ////////////////////////////////////////////////////////////////////////// //preprocess data first int** pctrvermark; if( !ispreproced || isComnCase) { pctrvermark = preProcData(isComnCase); //reset showcontourvers for( int i = 0; i < showplanenum; i ++) delete []showctrvers[ i ]; delete []showctrvers; //copy the data from processed data, and reset size showplanenum = planenum; showctrvers = new float*[ showplanenum ]; showctredgenum = new int[ showplanenum ]; showctredges = new int*[ showplanenum ]; for( int i = 0; i < showplanenum; i++ ) { int versize = pctrvernum[ i ]*3; showctrvers[ i ] = new float[ versize ]; for( int j = 0 ; j < versize; j ++ ) showctrvers[ i ][ j ] = pctrvers[ i ][ j ]*DIM/PROCSIZE; showctredgenum[ i ] = pctredgenum[ i ]; int edgesize = pctredgenum[ i ] * 2; showctredges[ i ] = new int[ edgesize ]; for( int j = 0; j < showctredgenum[ i ]; j ++) { showctredges[ i ][ 2*j ] = pctredges[ i ][ 4*j ]; showctredges[ i ][ 2*j + 1 ] = pctredges[ i ][ 4*j + 1]; } } for( int i = 0; i < planenum; i ++) { int iVerIndBase=0; vector<Point_3> CurrentProfile3D; for( int j = 0;j < showctredgenum[ i ]; j++) { int v1 = showctredges[ i ][ 2*j ]; int v2 = showctredges[ i ][ 2*j + 1 ]; CurrentProfile3D.push_back(Point_3(showctrvers[ i ][ v1* 3], showctrvers[ i ][ v1* 3+1], showctrvers[ i ][ v1* 3+2])); if (v2==iVerIndBase) { iVerIndBase=iVerIndBase+CurrentProfile3D.size(); MeshBoundingProfile3D.push_back(CurrentProfile3D); CurrentProfile3D.clear(); } } } //for( int i = 0; i < planenum; i ++) //{ // vector<Point_3> CurrentProfile3D; // for( int j = 0;j < showctredgenum[ i ]; j++) // { // int v1 = showctredges[ i ][ 2*j ]; // glVertex3fv( &showctrvers[ i ][ v1* 3] ); // CurrentProfile3D.push_back(Point_3(showctrvers[ i ][ v1* 3], // showctrvers[ i ][ v1* 3+1], // showctrvers[ i ][ v1* 3+2])); // } // MeshBoundingProfile3D.push_back(CurrentProfile3D); //} } ////////////////////////////////////////////////////////////////////////// //for( int i = 0; i < planenum + 4; i ++ ) //{ // cout<<pparam[ 4* i ]<<"," // <<pparam[ 4*i + 1]<<"," // <<pparam[ 4*i + 2]<<"," // <<pparam[ 4*i + 3]<<endl; //} //cout<<endl; ////////////////////////////////////////////////////////////////////////// //partition // cout<<"------------------ PARTITION ------------------"<<endl; // cout<<"Starting............"<<endl; partition(); ///////////////////////////////////////////////////////////B/////////////// /*writePartitionOut("mmdebug/partition.txt");*/ ////////////////////////////////////////////////////////////////////////// // cout<<"DONE!"<<endl<<endl; //process data // cout<<"------------------ PUT CONTOUR INTO FACE ------------------"<<endl; putContourIntoFace( pctrvermark ); //SaveCtr2FaceInfo(); if( isComnCase ) { for( int i = 0; i < planenum; i ++ ) delete []pctrvermark[ i ]; delete []pctrvermark; } ////////////////////////////////////////////////////////////////////////// // ContourHandler::writeContourInFace( ssfacenum, ctrfvernum, ctrfverpos, ctrfvertype, // ctrfverval, ctrfedgenum, ctrfedge, ctrfedgetype, ctrfedgeval ); ////////////////////////////////////////////////////////////////////////// // cout<<"DONE!"<<endl<<endl; //go through each subspace to generate mesh // cout<<"-------- GENERATING MESH IN EACH SUBSPACE ------------"<<endl; //kw noted: vertices, edges and faces in each subspace //stitch them together finally floatvector* subMeshVer; intvector* subMeshEdge; intvector* subMeshFace; subMeshVer = new floatvector[ ssspacenum ]; subMeshEdge = new intvector[ ssspacenum ]; subMeshFace = new intvector[ ssspacenum ]; //initialize registration informaiton for stitching sverreg = new intvector[ ssvernum ]; sedgereg = new vector<intvector>[ ssedgenum ]; sedgesubedgemark = new intvector[ ssedgenum ]; sfacectrei = new intset[ ssfacenum ]; sfacespaci = new int[ ssfacenum * 2 ]; sfaceregface = new vector<intvector>[ ssfacenum ]; sfaceregver = new intvector[ ssfacenum ]; sfaceregedgever = new intvector[ ssfacenum ]; for( int i = 0; i < ssfacenum*2; i ++) { sfacespaci[ i ] = -1; } for( int spacei = 0; spacei < ssspacenum; spacei ++) { for( int facej = 0; facej < ssspacefacenum[ spacei ]; facej ++) { int facei = ssspace[ spacei ][ facej ]; if( sfacespaci[ 2 * facei ] == -1) sfacespaci[ 2 * facei ] = spacei; else sfacespaci[ 2*facei + 1 ] = spacei; } } ////////////////////////////////////////////////////////////////////////// /*ancestorlist.resize( ssfacenum * 2 ); ancestorlist_split.resize( ssfacenum * 2 );*/ ////////////////////////////////////////////////////////////////////////// //return; dbSpaceNum = ssspacenum; if( dbOneSpaceMode ) { if( dbCurSpace < dbSpaceNum ) { ctr2sufSubspaceProc( dbCurSpace, subMeshVer[ dbCurSpace ], subMeshEdge[ dbCurSpace ], subMeshFace[ dbCurSpace ]); //submeshedge is useless for stitching! subMeshEdge[ dbCurSpace ].clear(); } } //kw: here can use multi-thread to compute each submesh in parallel else{ // for( int i = 7; i< 8; i ++) for( int i = 0; i < ssspacenum; i ++) // for( int i = 2; i < 3; i ++) // for( int i = 54; i < 55; i ++) // for(int i = 0; i < 12; i ++) // for( int i = 14; i < 15; i ++) { cout<<"--- subspace " << i <<endl; ctr2sufSubspaceProc( i, subMeshVer[ i ], subMeshEdge[ i ], subMeshFace[ i ]); //submeshedge is useless for stitching! subMeshEdge[ i ].clear(); } } delete []subMeshEdge; ////////////////////////////////////////////////////////////////////////// //cout<<"before splitting, ancestors:"<<endl; //for( int i = 0; i < ssfacenum*2; i +=2 ) //{ // if( ancestorlist[ i ].size() == 0 ) // { // if( ancestorlist[ i + 1].size() == 0 ) // continue; // } // intset::iterator iter = ancestorlist[ i ].begin(); //// intset::iterator iter2 = ancestorlist[ i + 1].begin(); // while( iter != ancestorlist[ i ].end() ) // { // cout<<*iter<<" "; // iter++; // } // cout<<endl; // iter = ancestorlist[ i+1 ].begin(); // while( iter != ancestorlist[ i + 1 ].end() ) // { // cout<<*iter <<" "; // iter ++; // } // cout<<endl; // cout<<"\n"; //} //cout<<"=============================\n"; //cout<<"after splitting ancestors:"<<endl; //for( int i= 0; i < ssfacenum*2; i += 2 ) //{ // if( ancestorlist_split[ i ].size() == 0 ) // { // if( ancestorlist_split[ i + 1].size() == 0) // continue; // } // intset::iterator iter = ancestorlist_split[ i ].begin(); // while( iter != ancestorlist_split[ i ].end() ) // { // cout<<*iter <<" "; // iter++; // // cout<<endl; // } // cout<<endl; // iter = ancestorlist_split[ i + 1].begin(); // while( iter != ancestorlist_split[ i + 1].end() ) // { // cout<<*iter <<" "; // iter ++; // } // cout<<endl<<endl; //} ////////////////////////////////////////////////////////////////////////// //cout the faces registered on the contour edges /*for( int i = 0; i < ssfacenum; i ++ ) { int ctrnum = sfaceregface[ i ].size()/2; if( ctrnum == 0 ) continue; intset::iterator iter = ancestorlist_split[2* i ].begin(); for( int j = 0; j < ctrnum; j ++ ) { cout<<"("<<*iter<<":"<<sfaceregface[ i ][ 2*j ] .size()<<","<< sfaceregface[ i ][ 2*j +1 ].size()<<") "; iter++; } cout<<endl; }*/ ////////////////////////////////////////////////////////////////////////// //for( int i = 0; i < ssfacenum; i ++) //{ // ancestorlist[ i].clear(); // ancestorlist_split[ i ].clear(); //} //ancestorlist_split.clear(); //ancestorlist.clear(); ////////////////////////////////////////////////////////////////////////// //stitch all the subspaces together stitchMesh(subMeshVer,subMeshFace); clock_t endt = clock(); cout<<"time difference is:"<<endt - start<<endl; DBWindowWrite("Reconstruction finished,taking: %d ms\n",endt - start); // struct __timeb64 timebuffer; // char *timeline; _ftime64( &timebuffer ); timeline = _ctime64( & ( timebuffer.time ) ); printf( "The time is %.19s.%hu %s", timeline, timebuffer.millitm, &timeline[20] ); // FaceGenerator::writeSubMeshOut( mver, mface, 99); //clear all the allocated space //for( int i = 0; i < ssspacenum; i ++) //{ // //subMeshVer[ i ].clear(); //// subMeshEdge[ i ].clear(); // subMeshFace[ i ].clear(); //} ////delete []subMeshVer; ////delete []subMeshEdge; //delete []subMeshFace; /*subMeshFace = NULL; subMeshVer = NULL;*/ //clear the registration information for subspace vertex, edge and face //sverreg for( int i = 0; i < ssvernum; i ++) sverreg[ i ].clear(); delete []sverreg; sverreg = NULL; //sedgereg for( int i= 0; i < ssedgenum; i ++) { for(unsigned int j = 0; j < sedgereg[ i ].size(); j ++) sedgereg[ i ][ j ].clear(); sedgereg[ i ].clear(); } delete []sedgereg; sedgereg = NULL; //sfacectrei, sfacespaci, sfaceregface, sfaceregver for( int i= 0; i < ssfacenum; i ++) { sfacectrei[ i ].clear(); // for( int j = 0; j < sfaceregface[ i ].size(); j ++ ) // sfaceregface[ i ][ j ].clear(); // sfaceregface[ i ].clear(); sfaceregver[ i ].clear(); } delete []sfacectrei; delete []sfacespaci; //delete []sfaceregface; delete []sfaceregver; sfacectrei = NULL; sfacespaci = NULL; //sfaceregface = NULL; sfaceregver = NULL; //set the mesh //clear if( mesh!= NULL ) delete mesh; //set mesh = new Mesh( mver, mface, ctrmedge, center, unitlen, PROCSIZE ); ////kw: get constrained vertices //set<int> ConstrVer; //for (unsigned int i=0;i<ctrmedge.size();i++) //{ // ConstrVer.insert(ctrmedge.at(i)); //} //for (set<int>::iterator SetIter=ConstrVer.begin();SetIter!=ConstrVer.end();SetIter++) //{ // vecTestPoint.push_back(Point_3(mver.at(3*(*SetIter))*DIM/PROCSIZE,mver.at(3*(*SetIter)+1)*DIM/PROCSIZE, // mver.at(3*(*SetIter)+2)*DIM/PROCSIZE)); //} mesh->setGLParam( width, height, nearplane, farplane); //clear mver.clear(); mface.clear(); ctrmedge.clear(); }
void KW_CS2Surf::GetSSMesh() { //faces in each subspace,each vector<int> represents a face composed of vertices with indices <int> vector<vector<vector<int>>> vecTotalFaceVer; //faces in each subspace,each int represents the face id of the facet in a subspace (a face may contain many facets(eg,triangles)) vector<vector<int>> vecTotalFace; //the order of each element in vecTotalFaceVer&vecTotalFace is consistent with the order of subspaces vecTotalFaceVer.resize(this->iSSspacenum); vecTotalFace.resize(this->iSSspacenum); for (unsigned int i=0;i<this->vecResortFace.size();i++) { ResortedFace currFace=vecResortFace.at(i); vector<int> currFaceVertexInd=currFace.vecFaceVertexInd; //the two subspace this face belongs to for (unsigned int j=0;j<currFace.vecOrient.size();j++) { int icurrSSId=currFace.vecSubspaceId.at(j); if (!currFace.vecOrient.at(j)) { reverse(currFaceVertexInd.begin(),currFaceVertexInd.end()); } vecTotalFaceVer.at(icurrSSId).push_back(currFaceVertexInd); vecTotalFace.at(icurrSSId).push_back(i); //reverse back to the originally saved order if (!currFace.vecOrient.at(j)) { reverse(currFaceVertexInd.begin(),currFaceVertexInd.end()); } } } //id of vertices stored in vecTotalFaceVer is the global vertex id,need to convert it //to the id within each subspace mesh //all the vertices are collected from the faces, so isolated vertices caused by the //subspace combination will not be taken account into consideration //subspace number after combination int iSSNumAfterComb=0; for (unsigned int i=0;i<vecTotalFaceVer.size();i++) { set<int> setSSVer; vector<vector<set<int>::iterator>> vecFaceSetIter; //put all vertex indices in, store the iterator for (unsigned int j=0;j<vecTotalFaceVer.at(i).size();j++) { vector<set<int>::iterator> currFaceSetIter; for (unsigned int k=0;k<vecTotalFaceVer.at(i).at(j).size();k++) { pair<set<int>::iterator, bool> pairResult=setSSVer.insert(vecTotalFaceVer.at(i).at(j).at(k)); currFaceSetIter.push_back(pairResult.first); } vecFaceSetIter.push_back(currFaceSetIter); } //get the id within the subspace according to the iterator vector<vector<int>> vecLocalVerInd; for (unsigned int j=0;j<vecFaceSetIter.size();j++) { vector<int> LocalFace; for (unsigned int k=0;k<vecFaceSetIter.at(j).size();k++) { int iLocalId=distance(setSSVer.begin(),vecFaceSetIter.at(j).at(k)); LocalFace.push_back(iLocalId); } vecLocalVerInd.push_back(LocalFace); } //convert to triangular mesh //a simple method (012345->012 023 034 045),may have bug vector<vector<int>> vecTriLocalVerInd; vector<int> vecTriFaceId;//the subspace face id of each triangle for (unsigned int j=0;j<vecLocalVerInd.size();j++) { vector<int> vecCurrFace=vecLocalVerInd.at(j); int iSecondVerLocalId=1; int iFacetFaceId=vecTotalFace.at(i).at(j); for (unsigned int k=0;k<vecCurrFace.size()-2;k++) { vector<int> vecTriFace; vecTriFace.push_back(vecCurrFace.at(0)); vecTriFace.push_back(vecCurrFace.at(iSecondVerLocalId)); vecTriFace.push_back(vecCurrFace.at(iSecondVerLocalId+1)); iSecondVerLocalId++; vecTriLocalVerInd.push_back(vecTriFace); vecTriFaceId.push_back(iFacetFaceId); } } //store all the points vector<Point_3> vecAllPoint; for (set<int>::iterator SetIter=setSSVer.begin();SetIter!=setSSVer.end();SetIter++) { vecAllPoint.push_back(Point_3(vecSSver.at(3*(*SetIter)), vecSSver.at(3*(*SetIter)+1), vecSSver.at(3*(*SetIter)+2))); } KW_Mesh currSSMesh; //if a subspace has been combined into others,still save it as an empty one, //in order to keep the order of subspaces if (!vecAllPoint.empty() && !vecTriLocalVerInd.empty()) { //Convert_Array_To_KW_Mesh<HalfedgeDS> triangle(vecAllPoint,vecLocalVerInd); Convert_Array_To_KW_Mesh<HalfedgeDS> triangle(vecAllPoint,vecTriLocalVerInd); currSSMesh.delegate(triangle); //record the face id of each triangle assert(currSSMesh.size_of_facets()==vecTriFaceId.size()); Facet_iterator FaceIter=currSSMesh.facets_begin(); for (unsigned int j=0;j<vecTriFaceId.size();j++) { FaceIter->SetReserved(vecTriFaceId.at(j)); FaceIter++; } } //save the subspace mesh if (!currSSMesh.empty()) { iSSNumAfterComb++; OBJHandle::UnitizeCGALPolyhedron(currSSMesh,false,false); } this->vecSSMesh.push_back(currSSMesh); ////test //if (!currSSMesh.empty()) //{ // OBJHandle::UnitizeCGALPolyhedron(currSSMesh,false,false); // this->vecSinglePoly.push_back(currSSMesh); //} } DBWindowWrite("initial subzone no.: %d\n",this->iSSspacenum); DBWindowWrite("subzone no. after combination: %d\n",iSSNumAfterComb); }
void KW_CS2Surf::CombineSS() { //iteratively combine until no SS can be combined while (true) { //collect subspaces need to be combined //pairs of subspaces to combine vector<Int_Int_Pair> vecSpacesToCombine; //the only face having CSs on in each subspace need to combine vector<int> vecValidFace; CollectSSToCombine(vecSpacesToCombine,vecValidFace); if (vecSpacesToCombine.empty())//no SS can be combined { break; } //start combination //in each list<int>,the first element is the id after combination, //the following elements are the id of subspaces to delete(note that this is opposite with the order in vecSpacesToCombine) vector<list<int>> vecSSComb; for (unsigned int i=0;i<vecSpacesToCombine.size();i++) { int iLeftSSId=-1;//id of subspace to be left int iDelSSId=-1;//id of subspace to delete for (unsigned int j=0;j<vecSSComb.size();j++) { list<int>::iterator pFindFirst=find(vecSSComb.at(j).begin(),vecSSComb.at(j).end(),vecSpacesToCombine.at(i).first); if (pFindFirst!=vecSSComb.at(j).end()) { if (pFindFirst==vecSSComb.at(j).begin()) { vecSSComb.at(j).push_front(vecSpacesToCombine.at(i).second); iLeftSSId=vecSpacesToCombine.at(i).second; iDelSSId=vecSpacesToCombine.at(i).first; } else { DBWindowWrite("error pair in subspace combination\n"); } break; } list<int>::iterator pFindSecond=find(vecSSComb.at(j).begin(),vecSSComb.at(j).end(),vecSpacesToCombine.at(i).second); if (pFindSecond!=vecSSComb.at(j).end()) { if (pFindSecond==vecSSComb.at(j).begin()) { vecSSComb.at(j).push_back(vecSpacesToCombine.at(i).first); iLeftSSId=vecSpacesToCombine.at(i).second; iDelSSId=vecSpacesToCombine.at(i).first; } else { vecSSComb.at(j).push_back(vecSpacesToCombine.at(i).first); iLeftSSId=vecSSComb.at(j).front(); iDelSSId=vecSpacesToCombine.at(i).first; } break; } } if (iLeftSSId==-1 && iDelSSId==-1) { //a fresh new pair list<int> ListNewPair; ListNewPair.push_back(vecSpacesToCombine.at(i).second); ListNewPair.push_back(vecSpacesToCombine.at(i).first); vecSSComb.push_back(ListNewPair); iLeftSSId=vecSpacesToCombine.at(i).second; iDelSSId=vecSpacesToCombine.at(i).first; } CombineTwoSS(iLeftSSId,iDelSSId,vecValidFace.at(i)); } } //compute mesh formed by each subspace GetSSMesh(); }
void CKWResearchWorkDoc::OnHelpTest() { // TODO: Add your command handler code here vector<Point_3> SamplePoints; GeometryAlgorithm::SampleCircle(Point_3(0,0,0),0.3,20,SamplePoints); FILE* pfile=fopen("circle0.contour","w"); for (unsigned int i=0;i<SamplePoints.size();i++) { fprintf(pfile,"%.3f %.3f %.3f\n",SamplePoints.at(i).x(),SamplePoints.at(i).y(),SamplePoints.at(i).z()); } fclose(pfile); Polygon_2 PolyTest; PolyTest.push_back(Point_2(0,0)); PolyTest.push_back(Point_2(1,1)); PolyTest.push_back(Point_2(2,0)); PolyTest.push_back(Point_2(2,2)); PolyTest.push_back(Point_2(0,2)); Point_2 ResultPoint; bool bResult=GeometryAlgorithm::GetArbiPointInPolygon(PolyTest,ResultPoint); DBWindowWrite("result point: %f %f\n",ResultPoint.x(),ResultPoint.y()); SparseMatrix LHMatrix(2); LHMatrix.m = 3; LHMatrix[0][0] = 2; LHMatrix[0][1] = -1; LHMatrix[0][2] = 1; LHMatrix[1][1] = 1; LHMatrix[1][2] = 1; SparseMatrix LHMatrixAT(LHMatrix.NCols()); CMath MathCompute; MathCompute.TAUCSFactorize(LHMatrix,LHMatrixAT); vector<vector<double>> RightMatB,ResultMat; vector<double> BRow; BRow.push_back(5);BRow.push_back(3); RightMatB.push_back(BRow); BRow.clear(); BRow.push_back(10);BRow.push_back(1); RightMatB.push_back(BRow); BRow.clear(); MathCompute.TAUCSComputeLSE(LHMatrixAT,RightMatB,ResultMat); return; int iVer=this->Mesh.size_of_vertices(); int iEdge=this->Mesh.size_of_halfedges(); int iFacet=this->Mesh.size_of_facets(); Polygon_2 BoundingPolygon0; Polygon_2 BoundingPolygon1; bool bSimple0=BoundingPolygon0.is_simple(); bool bSimple1=BoundingPolygon1.is_simple(); bool bConvex0=BoundingPolygon0.is_convex(); bool bConvex1=BoundingPolygon1.is_convex(); bool bOrien0=BoundingPolygon0.is_clockwise_oriented(); bool bOrien1=BoundingPolygon1.is_clockwise_oriented(); BoundingPolygon0.reverse_orientation(); BoundingPolygon1.reverse_orientation(); //float? bool bIntersect=CGAL::do_intersect(BoundingPolygon0,BoundingPolygon1); bool bCW=BoundingPolygon0.is_clockwise_oriented(); bool bConvex=BoundingPolygon0.is_convex(); Plane_3 plane(1,1,1,0); vector<vector<Point_3>> IntersectCurves; int iNum=GeometryAlgorithm::GetMeshPlaneIntersection(this->Mesh,plane,IntersectCurves); CMath CMathTest; CMathTest.testTAUCS(); // Vector_3 vec0(Point_3(0,0,1),Point_3(0,0,0)); Vector_3 vec0(Point_3(0,0,0),Point_3(0,0,1)); // Vector_3 vec0(0,0,1); // Vector_3 vec1(0,-1,-1); Vector_3 vec1(Point_3(0,0,0),Point_3(0,-1,-1)); double dAngle=GeometryAlgorithm::GetAngleBetweenTwoVectors3d(vec0,vec1); vector<double> number; number.push_back(2); number.push_back(4); number.push_back(4); number.push_back(4); number.push_back(5); number.push_back(5); number.push_back(7); number.push_back(9); double dderi=GeometryAlgorithm::GetDerivation(number); Point_3 center(0,0,0); Sphere_3 sphere(center,1); Line_3 line(Point_3(0,2,1),Point_3(0,2,-1)); vector<Point_3> points; GeometryAlgorithm::GetLineSphereIntersection(line,sphere,points); vector<Point_3> Group0,Group1; vector<Int_Int_Pair> GroupResult; Group0.push_back(Point_3(3,3,2)); Group0.push_back(Point_3(5,3,2)); Group0.push_back(Point_3(2,3,2)); Group0.push_back(Point_3(6,3,2)); Group0.push_back(Point_3(4,3,2)); Group0.push_back(Point_3(1,3,2)); Group1.push_back(Point_3(3,4,2)); Group1.push_back(Point_3(1,4,2)); Group1.push_back(Point_3(6,4,2)); Group1.push_back(Point_3(2,4,2)); Group1.push_back(Point_3(5,4,2)); Group1.push_back(Point_3(4,4,2)); vector<Point_3> vecMidPoint; GeometryAlgorithm::GroupNearestPoints(Group0,Group1,GroupResult,vecMidPoint);// vector<Point_3> OriginalCurve; OriginalCurve.push_back(Point_3(-1,0,2)); OriginalCurve.push_back(Point_3(1,0,2)); OriginalCurve.push_back(Point_3(1,0,0)); OriginalCurve.push_back(Point_3(-1,0,0)); vector<Point_3> NewCurve=OriginalCurve; vector<int> HandleInd; HandleInd.push_back(0); HandleInd.push_back(1); vector<Point_3> NewPos; NewPos.push_back(Point_3(-1,0,3)); NewPos.push_back(Point_3(1,0,3)); // CCurveDeform::ClosedCurveNaiveLaplacianDeform(NewCurve,HandleInd,NewPos,1); vector<vector<float>> MatrixA,MatrixB,Result; vector<float> CurrentRow; CurrentRow.push_back(2);CurrentRow.push_back(0);CurrentRow.push_back(1); MatrixA.push_back(CurrentRow); CurrentRow.clear(); CurrentRow.push_back(3);CurrentRow.push_back(1);CurrentRow.push_back(2); MatrixA.push_back(CurrentRow); CurrentRow.clear(); CurrentRow.push_back(0);CurrentRow.push_back(1);CurrentRow.push_back(0); MatrixA.push_back(CurrentRow); CurrentRow.clear(); CurrentRow.push_back(1);CurrentRow.push_back(3);CurrentRow.push_back(0); MatrixB.push_back(CurrentRow); CurrentRow.clear(); CurrentRow.push_back(2);CurrentRow.push_back(0);CurrentRow.push_back(2); MatrixB.push_back(CurrentRow); CurrentRow.clear(); CurrentRow.push_back(1);CurrentRow.push_back(0);CurrentRow.push_back(1); MatrixB.push_back(CurrentRow); CurrentRow.clear(); int iANonZeroSize=0; for (unsigned int i=0;i<MatrixA.size();i++) { for (unsigned int j=0;j<MatrixA.front().size();j++) { if (MatrixA.at(i).at(j)!=0) { iANonZeroSize++; } } } KW_SparseMatrix A(MatrixA.size(),MatrixA.front().size(),iANonZeroSize); for (unsigned int i=0;i<MatrixA.size();i++) { for (unsigned int j=0;j<MatrixA.front().size();j++) { if (MatrixA.at(i).at(j)!=0) { A.fput(i,j,MatrixA.at(i).at(j)); } } } int iBNonZeroSize=0; for (unsigned int i=0;i<MatrixB.size();i++) { for (unsigned int j=0;j<MatrixB.front().size();j++) { if (MatrixB.at(i).at(j)!=0) { iBNonZeroSize++; } } } KW_SparseMatrix B(MatrixB.size(),MatrixB.front().size(),iBNonZeroSize); for (unsigned int i=0;i<MatrixB.size();i++) { for (unsigned int j=0;j<MatrixB.front().size();j++) { if (MatrixB.at(i).at(j)!=0) { B.fput(i,j,MatrixB.at(i).at(j)); } } } KW_SparseMatrix C(A.m,B.n,0); KW_SparseMatrix::KW_multiply(A,B,C); int iIndex=0; Result.clear(); for (int i=0;i<C.m;i++) { vector<float> CurrentRow; for (int j=0;j<C.n;j++) { iIndex=0; while (iIndex<C.vol) { if (C.indx[iIndex]==i&&C.jndx[iIndex]==j) { break; } iIndex++; } if (iIndex!=C.vol) { CurrentRow.push_back(C.array[iIndex]); } else { CurrentRow.push_back(0); } } Result.push_back(CurrentRow); } }