void BookAR::updateData(const ci::Surface32f& image, gl::VboMesh& mesh, float max_height) { uint32_t book_w = image.getWidth(); uint32_t book_h = image.getHeight(); if (!mesh || mesh.getNumVertices() != book_w * book_h) {//needs refresh gl::VboMesh::Layout layout; layout.setDynamicColorsRGB(); layout.setDynamicPositions(); _mesh_book = gl::VboMesh( book_w * book_h, 0, layout, GL_POINTS ); } Surface32f::ConstIter pixelIter = image.getIter(); gl::VboMesh::VertexIter vertexIter( mesh ); while( pixelIter.line() ) { while( pixelIter.pixel() ) { Color color( pixelIter.r(), pixelIter.g(), pixelIter.b() ); float height = color.dot( Color( 0.3333f, 0.3333f, 0.3333f ) ); // the x and the z coordinates correspond to the pixel's x & y float x = pixelIter.x() - book_h / 2.0f; float z = pixelIter.y() - book_h / 2.0f; vertexIter.setPosition( x, height * max_height, z ); vertexIter.setColorRGB( color ); ++vertexIter; } } }
const ID & SimpleNumberer::number(Graph &theGraph, int lastVertex) { // first check our size, if not same make new if (numVertex != theGraph.getNumVertex()) { if (theRefResult != 0) delete theRefResult; numVertex = theGraph.getNumVertex(); theRefResult = new ID(numVertex); if (theRefResult == 0) { opserr << "ERROR: SimpleNumberer::number - Out of Memory\n"; theRefResult = new ID(0); numVertex = 0; return *theRefResult; } } // see if we can do quick return if (numVertex == 0) return *theRefResult; // Now we go through the iter and assign the numbers if (lastVertex != -1) { opserr << "WARNING: SimpleNumberer::number -"; opserr << " - does not deal with lastVertex"; } Vertex *vertexPtr; VertexIter &vertexIter = theGraph.getVertices(); int count = 0; while ((vertexPtr = vertexIter()) != 0) { (*theRefResult)(count++) = vertexPtr->getTag(); vertexPtr->setTmp(count); } return *theRefResult; }
MStatus tm_randPoint::undoIt() { if(helpMode) return MS::kSuccess; if(selVtxMode) { MSelectionList curSel; MGlobal::getActiveSelectionList( curSel); MItSelectionList iter( curSel, MFn::kMeshVertComponent); MObject component; MDagPath selVtx_dagPath; int vtxCount = 0; for ( ; !iter.isDone(); iter.next() ) { iter.getDagPath(selVtx_dagPath, component); MItMeshVertex vertexIter( selVtx_dagPath, component ); for ( ; !vertexIter.isDone(); vertexIter.next() ) { vertexIter.setPosition( oldPointsArrays[0][vtxCount], MSpace::kObject ); vtxCount++; } } } else { int num_meshes = res_MDagPathArray.length(); for( int i = 0; i < num_meshes; i++ ) { MDagPath dagPath = res_MDagPathArray[i]; MObject node; node = dagPath.node(); MFnDependencyNode fnNode( node ); MStatus polyStatus; MFnMesh fnMesh( node, &polyStatus ); if( polyStatus == MS::kSuccess ) { MStatus status; status = fnMesh.setPoints( oldPointsArrays[i]); if (!status){status.perror("### error setting point ::undoIt()");return status;} } } } return MS::kSuccess; }
MStatus convertVerticesToContainedEdgesCommand::redoIt() { MSelectionList finalEdgesSelection; MDagPath meshDagPath; MObject multiVertexComponent, singleVertexComponent; int dummyIndex; // ITERATE THROUGH EACH "VERTEX COMPONENT" THAT IS CURRENTLY SELECTED: for (MItSelectionList vertexComponentIter(previousSelectionList, MFn::kMeshVertComponent); !vertexComponentIter.isDone(); vertexComponentIter.next()) { // STORE THE DAGPATH, COMPONENT OBJECT AND MESH NAME OF THE CURRENT VERTEX COMPONENT: vertexComponentIter.getDagPath(meshDagPath, multiVertexComponent); MString meshName = meshDagPath.fullPathName(); // VERTEX COMPONENT HAS TO CONTAIN AT LEAST ONE VERTEX: if (!multiVertexComponent.isNull()) { // ITERATE THROUGH EACH "VERTEX" IN THE CURRENT VERTEX COMPONENT: for (MItMeshVertex vertexIter(meshDagPath, multiVertexComponent); !vertexIter.isDone(); vertexIter.next()) { // FOR STORING THE EDGES CONNECTED TO EACH VERTEX: MIntArray connectedEdgesIndices; vertexIter.getConnectedEdges(connectedEdgesIndices); // ITERATE THROUGH EACH EDGE CONNECTED TO THE CURRENT VERTEX: MItMeshEdge edgeIter(meshDagPath); for (unsigned i=0; i<connectedEdgesIndices.length(); i++) { // FIND AND STORE THE *FIRST* "END VERTEX" OF THE CURRENT EDGE: edgeIter.setIndex(connectedEdgesIndices[i], dummyIndex); MSelectionList singleVertexList; MString vertexName = meshName; vertexName += ".vtx["; vertexName += edgeIter.index(0); vertexName += "]"; singleVertexList.add(vertexName); singleVertexList.getDagPath(0, meshDagPath, singleVertexComponent); // SEE WHETHER THE VERTEX BELONGS TO THE ORIGINAL SELECTION, AND IF IT DOES PROCEED TO CHECK NEXT END VERTEX: if (!singleVertexComponent.isNull() && previousSelectionList.hasItem(meshDagPath, singleVertexComponent)) { // FIND AND STORE THE *SECOND* "END VERTEX" OF THE CURRENT EDGE: singleVertexList.clear(); vertexName = meshName; vertexName += ".vtx["; vertexName += edgeIter.index(1); vertexName += "]"; singleVertexList.add(vertexName); singleVertexList.getDagPath(0, meshDagPath, singleVertexComponent); // SEE WHETHER THE VERTEX BELONGS TO THE ORIGINAL SELECTION, AND IF IT DOES, ADD THE EDGE TO THE FINAL CONTAINED EDGES LIST: if (!singleVertexComponent.isNull() && previousSelectionList.hasItem(meshDagPath, singleVertexComponent)) { MString edgeName = meshName; edgeName += ".e["; edgeName += connectedEdgesIndices[i]; edgeName += "]"; finalEdgesSelection.add(edgeName); } } } } } } // FINALLY, MAKE THE NEW "CONTAINED EDGES", THE CURRENT SELECTION: MGlobal::setActiveSelectionList(finalEdgesSelection, MGlobal::kReplaceList); // RETURN NEW CONTAINED EDGES LIST FROM THE MEL COMMAND, AS AN ARRAY OF STRINGS: MStringArray containedEdgesArray; finalEdgesSelection.getSelectionStrings(containedEdgesArray); MPxCommand::setResult(containedEdgesArray); return MS::kSuccess; }
MStatus tm_randPoint::doIt( const MArgList& args ) { MStatus stat = MS::kSuccess; double amp = 1.0; double amp_x = 1.0; double amp_y = 1.0; double amp_z = 1.0; unsigned int seed = 0; bool useAxisAmp = false; bool exactObject = false; unsigned int num_meshes; MString objMString; helpMode = false; MArgDatabase argData( syntax(), args); if(argData.isFlagSet( help_Flag)) { helpMode = true; appendToResult( "\n// tm_polygon randPoint usage:\n"); appendToResult( "// Command operates with specified object with \"-obj\" flag,\n"); appendToResult( "// if this flag is not set, command use selected poly objects or poly vertices.\n"); appendToResult( "// Synopsis: tm_polygon [flags].\n"); appendToResult( "// Type \"help tm_randPoint\" to query flags.\n"); return MS::kSuccess; } if(argData.isFlagSet( amp_Flag)) argData.getFlagArgument( amp_Flag, 0, amp); if(argData.isFlagSet( ampX_Flag)) { argData.getFlagArgument( ampX_Flag, 0, amp_x); useAxisAmp = true; } if(argData.isFlagSet( ampY_Flag)) { argData.getFlagArgument( ampY_Flag, 0, amp_y); useAxisAmp = true; } if(argData.isFlagSet( ampZ_Flag)) { argData.getFlagArgument( ampZ_Flag, 0, amp_z); useAxisAmp = true; } if(argData.isFlagSet( seed_Flag)) argData.getFlagArgument( seed_Flag, 0, seed); if(argData.isFlagSet( obj_Flag)) { exactObject = true; argData.getFlagArgument( obj_Flag, 0, objMString); } double randMax = (double)RAND_MAX; double halfRandMax = 0.5 * randMax; unsigned i; if( exactObject) { selVtxMode = false; MSelectionList m_selList; MDagPath m_dagPath; stat = m_selList.add( objMString); if (!stat){stat.perror("###1 invalid obect path string");return stat;} stat = m_selList.getDagPath( 0, m_dagPath); if (!stat){stat.perror("###2 invalid obect path string");return stat;} stat = res_MDagPathArray.append( m_dagPath); if (!stat){stat.perror("###3 invalid obect path string");return stat;} } else { MSelectionList curSel; MGlobal::getActiveSelectionList( curSel); unsigned int numSelected = curSel.length(); MItSelectionList iter( curSel, MFn::kMeshVertComponent); if (iter.isDone()) { selVtxMode = false; MItDag::TraversalType traversalType = MItDag::kBreadthFirst; MFn::Type filter = MFn::kMesh; MItDag mit_dag( traversalType, filter, &stat); for( i = 0; i < numSelected; i++ ) { MDagPath sel_dagPath; curSel.getDagPath( i, sel_dagPath); stat = mit_dag.reset( sel_dagPath, traversalType, filter); if ( !stat) { stat.perror("MItDag constructor");return stat;} for ( ; !mit_dag.isDone(); mit_dag.next() ) { MDagPath m_dagPath; stat = mit_dag.getPath(m_dagPath); if ( !stat ) { stat.perror("MItDag::getPath error"); continue;} stat = res_MDagPathArray.append( m_dagPath); if ( !stat ) { stat.perror("MDagPathArray.append error"); continue;} } } } else { newPointsArrays = new MPointArray[1]; oldPointsArrays = new MPointArray[1]; selVtxMode = true; MObject component; MDagPath selVtx_dagPath; for ( ; !iter.isDone(); iter.next() ) { iter.getDagPath(selVtx_dagPath, component); MItMeshVertex vertexIter( selVtx_dagPath, component ); for ( ; !vertexIter.isDone(); vertexIter.next() ) { MPoint oldPoint = vertexIter.position(MSpace::kObject ); MPoint newPoint; newPoint.x = oldPoint.x + ((halfRandMax - (double)rand()) / randMax) * amp * amp_x; newPoint.y = oldPoint.y + ((halfRandMax - (double)rand()) / randMax) * amp * amp_y; newPoint.z = oldPoint.z + ((halfRandMax - (double)rand()) / randMax) * amp * amp_z; oldPointsArrays[0].append( oldPoint); newPointsArrays[0].append( newPoint); } } } } if(!selVtxMode) { num_meshes = res_MDagPathArray.length(); newPointsArrays = new MPointArray[num_meshes]; oldPointsArrays = new MPointArray[num_meshes]; for( i = 0; i < num_meshes; i++ ) { MDagPath dagPath = res_MDagPathArray[i]; MObject node; node = dagPath.node(); MFnDependencyNode fnNode( node ); MStatus polyStatus; MFnMesh fnMesh( node, &polyStatus ); if( polyStatus == MS::kSuccess ) { MStatus status; status = fnMesh.getPoints( oldPointsArrays[i]); if (!status){status.perror("### error getting mesh points");return stat;} unsigned int numVertices = oldPointsArrays[i].length(); newPointsArrays[i].setLength(numVertices); oldPointsArrays[i].setLength(numVertices); if(seed != 0) srand(seed); if(useAxisAmp) { for( unsigned int v = 0; v < numVertices; v++) { newPointsArrays[i][v].x = oldPointsArrays[i][v].x + ((halfRandMax - (double)rand()) / randMax) * amp * amp_x; newPointsArrays[i][v].y = oldPointsArrays[i][v].y + ((halfRandMax - (double)rand()) / randMax) * amp * amp_y; newPointsArrays[i][v].z = oldPointsArrays[i][v].z + ((halfRandMax - (double)rand()) / randMax) * amp * amp_z; } } else { for( unsigned int v = 0; v < numVertices; v++) { newPointsArrays[i][v].x = oldPointsArrays[i][v].x + ((halfRandMax - (double)rand()) / randMax) * amp; newPointsArrays[i][v].y = oldPointsArrays[i][v].y + ((halfRandMax - (double)rand()) / randMax) * amp; newPointsArrays[i][v].z = oldPointsArrays[i][v].z + ((halfRandMax - (double)rand()) / randMax) * amp; } } } else stat = MS::kFailure; } } return redoIt(); }
MStatus cvPos::doIt( const MArgList& args ) { MString componentName; MSpace::Space transformSpace = MSpace::kWorld; for (unsigned int i = 0; i < args.length (); i++) { MString argStr; args.get (i, argStr); if (MString ("-l") == argStr || MString ("-local") == argStr) transformSpace = MSpace::kObject; else if (MString ("-w") == args.asString (i) || MString ("-world") == argStr) transformSpace = MSpace::kWorld; else componentName = argStr; } MObject component; MDagPath dagPath; if (!componentName.length ()) { MSelectionList activeList; MGlobal::getActiveSelectionList (activeList); MItSelectionList iter (activeList, MFn::kComponent); if (iter.isDone ()) { displayError ("No components selected"); return MS::kFailure; } else { iter.getDagPath (dagPath, component); iter.next (); if (!iter.isDone ()) { displayError ("More than one component is selected"); return MS::kFailure; } } } else { MSelectionList list; if (! list.add( componentName ) ) { componentName += ": no such component"; displayError(componentName); return MS::kFailure; // no such component } MItSelectionList iter( list ); iter.getDagPath( dagPath, component ); } if (component.isNull()) { displayError("not a component"); return MS::kFailure; } switch (component.apiType()) { case MFn::kCurveCVComponent: { MItCurveCV curveCVIter( dagPath, component ); point = curveCVIter.position(transformSpace ); curveCVIter.next(); if (!curveCVIter.isDone()) { displayError ("More than one component is selected"); return MS::kFailure; } break; } case MFn::kSurfaceCVComponent: { MItSurfaceCV surfCVIter( dagPath, component, true ); point = surfCVIter.position(transformSpace ); surfCVIter.next(); if (!surfCVIter.isDone()) { displayError ("More than one component is selected"); return MS::kFailure; } break; } case MFn::kMeshVertComponent: { MItMeshVertex vertexIter( dagPath, component ); point = vertexIter.position(transformSpace ); vertexIter.next(); if (!vertexIter.isDone()) { displayError ("More than one component is selected"); return MS::kFailure; } break; } default: cerr << "Selected unsupported type: (" << component.apiType() << "): " << component.apiTypeStr() << endl; } return redoIt(); }
const ID & MyRCM::number(Graph &theGraph, int startVertex) { // first check our size, if not same make new if (numVertex != theGraph.getNumVertex()) { // delete the old if (theRefResult != 0) delete theRefResult; numVertex = theGraph.getNumVertex(); theRefResult = new ID(numVertex); if (theRefResult == 0) { opserr << "ERROR: MyRCM::number - Out of Memory\n"; theRefResult = new ID(0); numVertex = 0; return *theRefResult; } } // see if we can do quick return if (numVertex == 0) return *theRefResult; // we first set the Tmp of all vertices to -1, indicating // they have not yet been added. Vertex *vertexPtr; VertexIter &vertexIter = theGraph.getVertices(); while ((vertexPtr = vertexIter()) != 0) vertexPtr->setTmp(-1); // we now set up; setting our markers and getting first vertex if (startVertex != -1) startVertexTag = startVertex; if (startVertexTag != -1) { vertexPtr = theGraph.getVertexPtr(startVertexTag); if (vertexPtr == 0) { opserr << "WARNING: MyRCM::number - No vertex with tag "; opserr << startVertexTag << "Exists - using first come from iter\n"; startVertexTag = -1; } } // if no starting vertex use the first one we get from the VertexIter VertexIter &vertexIter2 = theGraph.getVertices(); if (startVertexTag == -1) vertexPtr = vertexIter2(); int currentMark = numVertex-1; // marks current vertex visiting. int nextMark = currentMark -1; // indiactes where to put next Tag in ID. (*theRefResult)(currentMark) = vertexPtr->getTag(); vertexPtr->setTmp(currentMark); // we continue till the ID is full while (nextMark >= 0) { // get the current vertex and its adjacency vertexPtr = theGraph.getVertexPtr((*theRefResult)(currentMark)); const ID &adjacency = vertexPtr->getAdjacency(); // go through the vertices adjacency and add vertices which // have not yet been Tmp'ed to the (*theRefResult) int size = adjacency.Size(); for (int i=0; i<size; i++) { int vertexTag = adjacency(i); vertexPtr = theGraph.getVertexPtr(vertexTag); if ((vertexPtr->getTmp()) == -1) { vertexPtr->setTmp(nextMark); (*theRefResult)(nextMark--) = vertexTag; } } // go to the next vertex // we decrement because we are doing reverse Cuthill-McKee currentMark--; // check to see if graph is disconneted if ((currentMark == nextMark) && (currentMark >= 0)) { opserr << "WARNING: MyRCM::number - Disconnected graph\n"; // loop over iter till we get a vertex not yet Tmped while (((vertexPtr = vertexIter2()) != 0) && (vertexPtr->getTmp() != -1)) ; nextMark--; vertexPtr->setTmp(currentMark); (*theRefResult)(currentMark) = vertexPtr->getTag(); } } // now set the vertex references instead of the vertex tags // in the result, we change the Tmp to indicate number and return for (int i=0; i<numVertex; i++) { int vertexTag = (*theRefResult)(i); vertexPtr = theGraph.getVertexPtr(vertexTag); vertexPtr->setTmp(i+1); // 1 through numVertex (*theRefResult)(i) = vertexPtr->getTag(); } theGraph.Print(opserr, 3); opserr << *theRefResult; return *theRefResult; }
const ID & MyRCM::number(Graph &theGraph, const ID &startVertices) { // first check our size, if not same make new if (numVertex != theGraph.getNumVertex()) { // delete the old if (theRefResult != 0) delete theRefResult; numVertex = theGraph.getNumVertex(); theRefResult = new ID(numVertex); if (theRefResult == 0) { opserr << "ERROR: MyRCM::number - Out of Memory\n"; theRefResult = new ID(0); numVertex = 0; return *theRefResult; } } // see if we can do quick return if (numVertex == 0) return *theRefResult; ID copyStart(startVertices); // we determine which node to start with int minStartVertexTag =0; int minAvgProfile = 0; int startVerticesSize = startVertices.Size(); for (int j=0; j<startVerticesSize; j++) { // we first set the Tmp of all vertices to -1, indicating // they have not yet been added. Vertex *vertexPtr; VertexIter &vertexIter = theGraph.getVertices(); while ((vertexPtr = vertexIter()) != 0) vertexPtr->setTmp(-1); // we now set up; setting our markers and set first vertices VertexIter &vertexIter2 = theGraph.getVertices(); int currentMark = numVertex-1; // marks current vertex visiting. int nextMark = currentMark-1; for (int k=0; k<startVerticesSize; k++) if (k != j) copyStart(k) = 0; else copyStart(k) = 1; vertexPtr = theGraph.getVertexPtr(startVertices(j)); (*theRefResult)(currentMark) = vertexPtr->getTag(); vertexPtr->setTmp(currentMark); int numFromStart = 1; int avgProfile = 1; while (numFromStart < startVerticesSize) { // get the current vertex and its adjacency vertexPtr = theGraph.getVertexPtr((*theRefResult)(currentMark)); const ID &adjacency = vertexPtr->getAdjacency(); // go through the vertices adjacency and add vertices which // have not yet been Tmp'ed to the (*theRefResult) int size = adjacency.Size(); for (int i=0; i<size; i++) { int vertexTag = adjacency(i); int loc =startVertices.getLocation(vertexTag); if (loc >= 0) { vertexPtr = theGraph.getVertexPtr(vertexTag); if ((vertexPtr->getTmp()) == -1) { vertexPtr->setTmp(nextMark); copyStart(loc) = 1; numFromStart++; avgProfile += currentMark - nextMark; (*theRefResult)(nextMark--) = vertexTag; } } } // go to the next vertex // we decrement because we are doing reverse Cuthill-McKee currentMark--; // check to see if graph is disconneted if (currentMark == nextMark && numFromStart < startVerticesSize) { // loop over iter till we get a vertex not yet included for (int l=0; l<startVerticesSize; l++) if (copyStart(l) == 0) { int vertexTag = startVertices(l); vertexPtr = theGraph.getVertexPtr(vertexTag); nextMark--; copyStart(l) = 1; vertexPtr->setTmp(currentMark); numFromStart++; (*theRefResult)(currentMark) = vertexPtr->getTag(); l =startVerticesSize; } } } currentMark = numVertex-1; // set current to the first again nextMark = numVertex - startVerticesSize -1; // we continue till the ID is full while (nextMark >= 0) { // get the current vertex and its adjacency vertexPtr = theGraph.getVertexPtr((*theRefResult)(currentMark)); const ID &adjacency = vertexPtr->getAdjacency(); // go through the vertices adjacency and add vertices which // have not yet been Tmp'ed to the (*theRefResult) int size = adjacency.Size(); for (int i=0; i<size; i++) { int vertexTag = adjacency(i); vertexPtr = theGraph.getVertexPtr(vertexTag); if ((vertexPtr->getTmp()) == -1) { vertexPtr->setTmp(nextMark); avgProfile += currentMark - nextMark; (*theRefResult)(nextMark--) = vertexTag; } } // go to the next vertex // we decrement because we are doing reverse Cuthill-McKee currentMark--; // check to see if graph is disconneted if ((currentMark == nextMark) && (currentMark >= 0)) { // loop over iter till we get a vertex not yet Tmped while (((vertexPtr = vertexIter2()) != 0) && (vertexPtr->getTmp() != -1)) ; nextMark--; vertexPtr->setTmp(currentMark); (*theRefResult)(currentMark) = vertexPtr->getTag(); } } if (j == 0 || minAvgProfile > avgProfile) { minStartVertexTag = startVertices(j); minAvgProfile = avgProfile; } } // now we numebr based on minStartVErtexTag // we first set the Tmp of all vertices to -1, indicating // they have not yet been added. Vertex *vertexPtr; VertexIter &vertexIter = theGraph.getVertices(); while ((vertexPtr = vertexIter()) != 0) vertexPtr->setTmp(-1); // we now set up; setting our markers and set first vertices VertexIter &vertexIter2 = theGraph.getVertices(); int currentMark = numVertex-1; // marks current vertex visiting. int nextMark = currentMark-1; vertexPtr = theGraph.getVertexPtr(minStartVertexTag); (*theRefResult)(currentMark) = vertexPtr->getTag(); vertexPtr->setTmp(currentMark); currentMark--; int loc = startVertices.getLocation(minStartVertexTag); for (int k=0; k<startVerticesSize; k++) if (k != loc) copyStart(k) = 0; int numFromStart = 1; while (numFromStart < startVerticesSize) { // get the current vertex and its adjacency vertexPtr = theGraph.getVertexPtr((*theRefResult)(currentMark)); const ID &adjacency = vertexPtr->getAdjacency(); // go through the vertices adjacency and add vertices which // have not yet been Tmp'ed to the (*theRefResult) int size = adjacency.Size(); for (int i=0; i<size; i++) { int vertexTag = adjacency(i); int loc =startVertices.getLocation(vertexTag); if (loc >= 0) { vertexPtr = theGraph.getVertexPtr(vertexTag); if ((vertexPtr->getTmp()) == -1) { vertexPtr->setTmp(nextMark); copyStart(loc) = 1; numFromStart++; (*theRefResult)(nextMark--) = vertexTag; } } } // go to the next vertex // we decrement because we are doing reverse Cuthill-McKee currentMark--; // check to see if graph is disconneted if (currentMark == nextMark && numFromStart < startVerticesSize) { // loop over iter till we get a vertex not yet included for (int l=0; l<startVerticesSize; l++) if (copyStart(l) == 0) { int vertexTag = startVertices(l); vertexPtr = theGraph.getVertexPtr(vertexTag); nextMark--; copyStart(l) = 1; vertexPtr->setTmp(currentMark); numFromStart++; (*theRefResult)(currentMark) = vertexPtr->getTag(); l =startVerticesSize; } } } currentMark = numVertex-1; // set current to the first again nextMark = numVertex - startVerticesSize -1; currentMark = numVertex-1; // set current to the first again // we continue till the ID is full while (nextMark >= 0) { // get the current vertex and its adjacency vertexPtr = theGraph.getVertexPtr((*theRefResult)(currentMark)); const ID &adjacency = vertexPtr->getAdjacency(); // go through the vertices adjacency and add vertices which // have not yet been Tmp'ed to the (*theRefResult) int size = adjacency.Size(); for (int i=0; i<size; i++) { int vertexTag = adjacency(i); vertexPtr = theGraph.getVertexPtr(vertexTag); if ((vertexPtr->getTmp()) == -1) { vertexPtr->setTmp(nextMark); (*theRefResult)(nextMark--) = vertexTag; } } // go to the next vertex // we decrement because we are doing reverse Cuthill-McKee currentMark--; // check to see if graph is disconneted if ((currentMark == nextMark) && (currentMark >= 0)) { opserr << "WARNING: MyRCM::number - Disconnected graph "; // loop over iter till we get a vertex not yet Tmped while (((vertexPtr = vertexIter2()) != 0) && (vertexPtr->getTmp() != -1)) ; nextMark--; vertexPtr->setTmp(currentMark); (*theRefResult)(currentMark) = vertexPtr->getTag(); } } // now set the vertex references instead of the vertex tags // in the result, we change the Tmp to indicate number and return for (int m=0; m<numVertex; m++) { int vertexTag = (*theRefResult)(m); vertexPtr = theGraph.getVertexPtr(vertexTag); vertexPtr->setTmp(m+1); // 1 through numVertex (*theRefResult)(m) = vertexPtr->getTag(); } return *theRefResult; }
MStatus lassoTool::doRelease( MEvent & /*event*/ ) // Selects objects within the lasso { MStatus stat; MSelectionList incomingList, boundingBoxList, newList; if (!firstDraw) { // Redraw the lasso to clear it. view.beginXorDrawing(true, true, 1.0f, M3dView::kStippleDashed); draw_lasso(); view.endXorDrawing(); } // We have a non-zero sized lasso. Close the lasso, and sort // all the points on it. append_lasso(lasso[0].h, lasso[0].v); qsort( &(lasso[0]), num_points, sizeof( coord ), (int (*)(const void *, const void *))xycompare); // Save the state of the current selections. The "selectFromSceen" // below will alter the active list, and we have to be able to put // it back. MGlobal::getActiveSelectionList(incomingList); // As a first approximation to the lasso, select all components with // the bounding box that just contains the lasso. MGlobal::selectFromScreen( min.h, min.v, max.h, max.v, MGlobal::kReplaceList ); // Get the list of selected items from within the bounding box // and create a iterator for them. MGlobal::getActiveSelectionList(boundingBoxList); // Restore the active selection list to what it was before we // the "selectFromScreen" MGlobal::setActiveSelectionList(incomingList, MGlobal::kReplaceList); // Iterate over the objects within the bounding box, extract the // ones that are within the lasso, and add those to newList. MItSelectionList iter(boundingBoxList); newList.clear(); bool foundEntireObjects = false; bool foundComponents = false; for ( ; !iter.isDone(); iter.next() ) { MDagPath dagPath; MObject component; MPoint point; coord pt; MObject singleComponent; iter.getDagPath( dagPath, component ); if (component.isNull()) { foundEntireObjects = true; continue; // not a component } foundComponents = true; switch (component.apiType()) { case MFn::kCurveCVComponent: { MItCurveCV curveCVIter( dagPath, component, &stat ); for ( ; !curveCVIter.isDone(); curveCVIter.next() ) { point = curveCVIter.position(MSpace::kWorld, &stat ); view.worldToView( point, pt.h, pt.v, &stat ); if (!stat) { stat.perror("Could not get position"); continue; } if ( point_in_lasso( pt ) ) { singleComponent = curveCVIter.cv(); newList.add (dagPath, singleComponent); } } break; } case MFn::kSurfaceCVComponent: { MItSurfaceCV surfCVIter( dagPath, component, true, &stat ); for ( ; !surfCVIter.isDone(); surfCVIter.next() ) { point = surfCVIter.position(MSpace::kWorld, &stat ); view.worldToView( point, pt.h, pt.v, &stat ); if (!stat) { stat.perror("Could not get position"); continue; } if ( point_in_lasso( pt ) ) { singleComponent = surfCVIter.cv(); newList.add (dagPath, singleComponent); } } break; } case MFn::kMeshVertComponent: { MItMeshVertex vertexIter( dagPath, component, &stat ); for ( ; !vertexIter.isDone(); vertexIter.next() ) { point = vertexIter.position(MSpace::kWorld, &stat ); view.worldToView( point, pt.h, pt.v, &stat ); if (!stat) { stat.perror("Could not get position"); continue; } if ( point_in_lasso( pt ) ) { singleComponent = vertexIter.vertex(); newList.add (dagPath, singleComponent); } } break; } case MFn::kMeshEdgeComponent: { MItMeshEdge edgeIter( dagPath, component, &stat ); for ( ; !edgeIter.isDone(); edgeIter.next() ) { point = edgeIter.center(MSpace::kWorld, &stat ); view.worldToView( point, pt.h, pt.v, &stat ); if (!stat) { stat.perror("Could not get position"); continue; } if ( point_in_lasso( pt ) ) { singleComponent = edgeIter.edge(); newList.add (dagPath, singleComponent); } } break; } case MFn::kMeshPolygonComponent: { MItMeshPolygon polygonIter( dagPath, component, &stat ); for ( ; !polygonIter.isDone(); polygonIter.next() ) { point = polygonIter.center(MSpace::kWorld, &stat ); view.worldToView( point, pt.h, pt.v, &stat ); if (!stat) { stat.perror("Could not get position"); continue; } if ( point_in_lasso( pt ) ) { singleComponent = polygonIter.polygon(); newList.add (dagPath, singleComponent); } } break; } default: #ifdef DEBUG cerr << "Selected unsupported type: (" << component.apiType() << "): " << component.apiTypeStr() << endl; #endif /* DEBUG */ continue; } } // Warn user if zie is trying to select objects rather than components. if (foundEntireObjects && !foundComponents) { MGlobal::displayWarning("lassoTool can only select components, not entire objects."); } // Update the selection list as indicated by the modifier keys. MGlobal::selectCommand(newList, listAdjustment); // Free the memory that held our lasso points. free(lasso); lasso = (coord*) 0; maxSize = 0; num_points = 0; return MS::kSuccess; }