vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) { int m = nums1.size(), n = nums2.size(); vector<int> res(k, 0); for (int i=max(0, k-n); i<=min(k, m); i++) { auto v1 = maxV(nums1, i); auto v2 = maxV(nums2, k-i); auto tmp = merge(v1, v2, k); if (compare(tmp, 0, res, 0)) res = tmp; } return res; }
void CameraManager::updateCurrent_(float dt) { glm::vec3 dx = target_ - current_; glm::vec3 maxV(getParam("camera.maxVx"), getParam("camera.maxVy"), getParam("camera.maxVz")); // If we're trying to move faster than we're allowed, // clip our velocity in that direction. if (fabs(dx.x) > maxV.x * dt) { dx.x = dx.x < 0 ? -1 * maxV.x * dt : maxV.x * dt; } if (fabs(dx.y) > maxV.y * dt) { dx.y = dx.y < 0 ? -1 * maxV.y * dt : maxV.y * dt; } if (fabs(dx.z) > maxV.z * dt) { dx.z = dx.z < 0 ? -1 * maxV.z * dt : maxV.z * dt; } current_ = current_ + dx; setCamera(current_); }
int maximumGap(vector<int> &num) { int n = num.size(); if( n < 2 ) return 0; if( n == 2 ) return abs( num[0] - num[1] ); int Min = *min_element( num.begin() , num.end() ); int Max = *max_element( num.begin() , num.end() ); double d = double( Max - Min ) / ( n - 1 ); vector< int > maxV( n - 1 , -1 ); vector< int > minV( n - 1 , -1 ); for( int x : num ) { int hop = ( x == Max ? n-2 : double( x - Min ) / d ); maxV[hop] = max( maxV[hop] , x ); if( minV[hop] == -1 || minV[hop] > x ) minV[hop] = x; } n--; int i = 0, ret = 0; while( i < n && minV[i] == -1 ) i++; while( i < n ) { int j = i+1; while( j < n && minV[j] == -1 ) j++; if( j == n ) break; ret = max( ret , minV[j] - maxV[i] ); i = j; } return ret; }
GlReplicateAddOn::GlReplicateAddOn() : inherited(SZI[SZI_arp], GL_REPLICATE_KEY, SZ(SZ_Combine), SZ(SZ_Replicate), 1, 0) { GlRelAbs minV(0, 0), maxV(1, 256); // mDepth = AddParamType(new GlFloatParamType(_DEPTH_KEY, "Depth", 0, 1, 0.5, 0.01)); AddParamType(new GlRelAbsParamType(_DEPTH_KEY, SZ(SZ_Depth), minV, maxV, gInit, 0.01f)); }
/* Aplica o modelo de iluminação para o cálculo da cor do vértice corrente. * * Argumentos de entrada: * 'vertex_ec' : Localização do vértice representada no sistema de coordenadas da câmera (eye coordinates, EC). * 'unit_normal_ec' : Vetor normal à superfície representado no sistema de coordenadas da câmera (EC). Assume-se que * a norma deste vetor é igual a 1.0f. * 'base_color' : Cor base para o vértice. Utilizada quando a iluminação está desabilitada. * 'lighting_enabled' : Indica se a iluminação está habilitada. * 'material_ambient' : Cor da componente ambiente do material. * 'material_diffuse' : Cor da componente difusa do material. * 'material_specular' : Cor da componente especular do material. * 'material_shininess': Expoente que define o tamanho do brilho especular do material. * 'light_ec' : Localização da fonte de luz no sistema de coordenadas da câmera (EC). * 'light_ambient' : Intensidade da componente ambiente da fonte de luz. * 'light_diffuse' : Intensidade da componente difusa da fonte de luz. * 'light_specular' : Intensidade da componente especular da fonte de luz. * * Argumentos de saída: * 'vertex_color' : Cor do vértice corrente. É igual a 'base_color' caso a iluminação esteja desabilitada ou é * calculada por meio de modelo de reflexão de Blin-Phong, caso contrário. */ void vertex_lighting(const location_struct &vertex_ec, const direction_struct &unit_normal_ec, const color_struct &base_color, bool lighting_enabled, const color_struct &material_ambient, const color_struct &material_diffuse, const color_struct &material_specular, float material_shininess, const location_struct &light_ec, const color_struct &light_ambient, const color_struct &light_diffuse, const color_struct &light_specular, color_struct &vertex_color) { // Calcular 'vertex_color'. direction_struct S = direction_struct(); direction_struct V = direction_struct(); direction_struct H = direction_struct(); if(lighting_enabled) { //Diffuse S.x = light_ec.x - vertex_ec.x; S.y = light_ec.y - vertex_ec.y; S.z = light_ec.z - vertex_ec.z; normalize(S); float dotProductDiffuse = dotProduct (S, unit_normal_ec); color_struct lightDiffuse = color_struct(); lightDiffuse.r = light_diffuse.r * material_diffuse.r * maxV(dotProductDiffuse, 0.0f); lightDiffuse.g = light_diffuse.g * material_diffuse.g * maxV(dotProductDiffuse, 0.0f); lightDiffuse.b = light_diffuse.b * material_diffuse.b * maxV(dotProductDiffuse, 0.0f); lightDiffuse.a = light_diffuse.a * material_diffuse.a * maxV(dotProductDiffuse, 0.0f); //Specular V.x = - vertex_ec.x; V.y = - vertex_ec.y; V.z = - vertex_ec.z; normalize(V); H.x = S.x + V.x; H.y = S.y + V.y; H.z = S.z + V.z; normalize(H); float dotProductSpecular = dotProduct(H, unit_normal_ec); color_struct lightSpecular = color_struct(); lightSpecular.r = light_specular.r * material_specular.r * pow(maxV(dotProductSpecular, 0.0f), material_shininess); lightSpecular.g = light_specular.g * material_specular.g * pow(maxV(dotProductSpecular, 0.0f), material_shininess); lightSpecular.b = light_specular.b * material_specular.b * pow(maxV(dotProductSpecular, 0.0f), material_shininess); lightSpecular.a = light_specular.a * material_specular.a * pow(maxV(dotProductSpecular, 0.0f), material_shininess); //Ambient color_struct lightAmbient = color_struct(); lightAmbient.r = light_ambient.r * material_ambient.r; lightAmbient.g = light_ambient.g * material_ambient.g; lightAmbient.b = light_ambient.b * material_ambient.b; lightAmbient.a = light_ambient.a * material_ambient.a; //Result vertex_color = color_struct(lightDiffuse.r + lightSpecular.r + lightAmbient.r, lightDiffuse.g + lightSpecular.g + lightAmbient.g, lightDiffuse.b + lightSpecular.b + lightAmbient.b, 1.0f); } else { vertex_color = color_struct(base_color); } }
int uniquePaths(int m, int n) { vector<int> maxV(n,0); maxV[0]=1; for(int i =0; i< m; i++) { for(int j =1; j<n; j++) { maxV[j] = maxV[j-1] + maxV[j]; } } return maxV[n-1]; }
ProductVersion ProductVersions::FindMax(ProductVersion const &v, bool devel) const { ProductVersion maxV(v); for(int i = 0; i < GetCount(); i++) { if(!devel && operator[](i).IsDevel()) continue; if(operator[](i) > maxV) maxV = operator[](i); } return maxV; }
void ITKImplicit::init(void) { //init from surface //Via dynamic cast we test whether the surface type allows for a transformation //into an ITKImplicit if (!surface) return; //init default image, this can still be overwritten myImage = ImageType::New(); SurfaceMesh * mesh=dynamic_cast<SurfaceMesh*>(surface); if (mesh) { mesh->computeBoundingBox(); gmVector3 maxV(mesh->bbox_max[0], mesh->bbox_max[1], mesh->bbox_max[2]); gmVector3 minV(mesh->bbox_min[0], mesh->bbox_min[1], mesh->bbox_min[2]); initScalingAndOriginFromBoundingBox(minV,maxV); //we have a special surface, a mesh surface initFromSurfaceMesh(mesh); } //surface could be an implicit Implicit * imp=dynamic_cast<Implicit*>(surface); if (imp) { //if we have an implicit we want to check whether the particle bounding box is set. //if so, we adjust the image if (bbox) { //we have a bounding box, so we use it to evaluate the //values. initScalingAndOriginFromBoundingBox(bbox->min, bbox->max); } else { initScalingAndOriginFromBoundingBox(gmVector3(-0.5,-0.5,-0.5), gmVector3(0.5,0.5,0.5)); } initFromImplicit(imp); } originalSpacing = myImage->GetSpacing(); originalOrigin = myImage->GetOrigin(); //we apply eventual transformations //and init the spline interpolator //we refit the particles bounding box applyParameterChanges(); }
void PhysicsManager::addLevelGeometry( Ogre::Entity* levelEntity, const std::vector<OgreNewt::CollisionPtr> &collisions) { RlAssert1(levelEntity); RlAssert1(levelEntity->getParentSceneNode()); SceneNode* node = levelEntity->getParentSceneNode(); //Level entity has to be attached to a scene node. // try one compound collision for the entity if there are several collisions OgreNewt::CollisionPtr collision; switch( collisions.size() ) { case 0: break; case 1: collision = collisions[0]; break; default: collision = OgreNewt::CollisionPtr(new OgreNewt::CollisionPrimitives::CompoundCollision(mWorld, collisions, 0)); break; } if( collision ) { OgreNewt::Body* body = new OgreNewt::Body(mWorld, collision ); body->attachNode(node); body->setPositionOrientation(node->_getDerivedPosition(), node->_getDerivedOrientation()); body->setMaterialGroupID(getMaterialID("level")); mLevelBodiesQuadTree.add(body); //mLevelBodies.push_back(body); } // adjust worldAABB Vector3 minV(mWorldAABB.getMinimum()); Vector3 maxV(mWorldAABB.getMaximum()); AxisAlignedBox entityAABB = levelEntity->getWorldBoundingBox(true); minV.makeFloor(entityAABB.getMinimum()); maxV.makeCeil(entityAABB.getMaximum()); mWorldAABB.setMinimum(minV - Vector3(50, 50, 50)); mWorldAABB.setMaximum(maxV + Vector3(50, 50, 50)); mWorld->setWorldSize(mWorldAABB); }
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { int max = maxV(p, q), min = minV(p, q); if(root == NULL) return NULL; TreeNode* temp = root; while(temp != NULL) { if(temp->val == max || temp->val == min) return temp; if(temp->val > max) { temp = temp->left; } else if(temp->val < min) { temp = temp->right; } else return temp; } }
bool brightRGB::getMax(const image& img,dvector& dest) const{ // image empty? if (img.empty()) { setStatusString("image empty"); dest.resize(0); return false; } const rgbPixel transColor = getParameters().transColor; ivector maxV(3,-1); image::const_iterator it = img.begin(); if(getParameters().transparent) { while(it != img.end()) { if(*it != transColor) { if((*it).getRed() > maxV.at(0)) maxV.at(0) = (*it).getRed(); if((*it).getGreen() > maxV.at(1)) maxV.at(1) = (*it).getGreen(); if((*it).getBlue() > maxV.at(2)) maxV.at(2) = (*it).getBlue(); } it++; } // only transparent pixels? if (maxV.at(0)==-1) { setStatusString("only transparent pixels"); dest.resize(0); return false; } } else { // no transparent color while(it != img.end()) { if((*it).getRed() > maxV.at(0)) maxV.at(0) = (*it).getRed(); if((*it).getGreen() > maxV.at(1)) maxV.at(1) = (*it).getGreen(); if((*it).getBlue() > maxV.at(2)) maxV.at(2) = (*it).getBlue(); it++; } } if(maxV.at(0) == -1) return false; dest.castFrom(maxV); // normalize to 0..1 dest.divide(255); return true; };
// CREATEPLHKPHYSICALFROMMESHEASY // Convenience function for getting from a max node to a plHKPhysical and the requisite // Havok objects. // The node and the scene object don't have to correspond to the same Max object. // If the sAltNode is supplied, the node will be moved into the coordinate system of the bool plMaxMeshExtractor::Extract(plMaxMeshExtractor::NeutralMesh& mesh, plMaxNode* node, bool makeAABB, plMaxNode* sOwningNode) { mesh.fNumVerts = mesh.fNumFaces = 0; mesh.fVerts = nil; mesh.fFaces = nil; // if an alternate node was supplied, get its scene object. otherwise don't... plMaxNode* masterNode = sOwningNode ? sOwningNode : node; mesh.fL2W = masterNode->GetLocalToWorld44(); // // Create the arrays of verts and faces // bool isDummy = (node->EvalWorldState(0).obj->ClassID() == Class_ID(DUMMY_CLASS_ID,0)); if (isDummy) { hsMatrix44 w2l = masterNode->GetWorldToLocal44(); MakeDummyMesh(node, mesh); // Localize the verts //for (int i = 0; i < mesh.fNumVerts; i++) // mesh.fVerts[i] = w2l * mesh.fVerts[i]; } else { // only get the max world-to-local transform if the node is moveable or instanced. otherwise verts stay global. Matrix3 w2l = masterNode->GetWorldToLocal(); // Matrix3 *localizer = nil; // if (masterNode->IsMovable() || masterNode->GetForceLocal() || masterNode->GetInstanced()) // localizer = &w2l; if (!MakeNormalMesh(node, mesh, &w2l)) return false; if (makeAABB) { hsPoint3 minV(FLT_MAX, FLT_MAX, FLT_MAX), maxV(-FLT_MAX, -FLT_MAX, -FLT_MAX); MeshMinMax(minV, maxV, mesh.fNumVerts, mesh.fVerts); MakeBoxMesh(node, mesh, minV, maxV); } } return true; }
int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) { int m = obstacleGrid.size(); if(m == 0) return 0; int n = obstacleGrid[0].size(); if(n == 0 || obstacleGrid[0][0] == 1) return 0; vector<int> maxV(n, 0); maxV[0] =1; for(int i = 0; i < m; i++){ for(int j = 0; j < n; j++){ if(obstacleGrid[i][j] ==1) maxV[j] = 0; else if(j >0) maxV[j] = maxV[j-1] + maxV[j]; //dp[i][j] = dp[i][j-1] + dp[i-1][j] } } return maxV[n-1]; }
int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid) { // Note: The Solution object is instantiated only once and is reused by each test case. int m = obstacleGrid.size(); if(m ==0) return 0; int n = obstacleGrid[0].size(); if (obstacleGrid[0][0] == 1) return 0; vector<int> maxV(n,0); maxV[0] = 1; for (int i = 0; i < m; ++i) { for (int j = 0; j < n; ++j) { if (obstacleGrid[i][j]==1) maxV[j] = 0; else if (j > 0) maxV[j] = maxV[j-1] + maxV[j]; } } return maxV[n-1]; }
/** * Print some informations concerning the object in a std::string and does a cleanup of the * memory. * * @return A std::string. **/ std::string stats() { std::string s; s += "*****************************************************\n"; s += "BitGraphZ2 object statistics\n\n"; s += "- memory used : " + toString(memory()) + "Mb\n"; s += "- lattice represented : [ " + toString(minV()) + " , " + toString(maxV()) + " ]^2\n"; s += "- Main grid size : [ " + toString(-LL) + " , " + toString(LL-1) + " ]^2 (" + toString((4*sizeof(int32)*LL*LL)/(1024*1024)) + "Mb)\n"; s += "- Size of a subsquare : " + toString(N*8) + " x " + toString(N*8) + " (" + toString(sizeof(_MSQ)) + "b each)\n"; s += "- Number of subsquare : " + toString(VV) + " (" + toString(((int64)VV)*sizeof(_MSQ) /(1024*1024)) + "Mb)\n\n"; s += "Number of point set : " + toString(nbSet()) + "\n"; s += "Surrounding square : "; if (minX() != LLONG_MAX) { s += "[ " + toString(minX()) + " , " + toString(maxX()) + " ] x [ " + toString(minY()) + " , " + toString(maxY()) + " ]\n"; } else {s += "No point set yet !\n";} s += "Memory used before cleanup\t" + toString(v) + "/" + toString(VV) + " (" + toString((int)(100*(((double)v)/((double)VV))))+ "%)\n"; cleanup(); s += "Memory used after cleanup\t" + toString(v) + "/" + toString(VV) + " (" + toString((int)(100*(((double)v)/((double)VV))))+ "%)\n"; s += "*****************************************************\n"; return s; }
BoundingBox3D Triangle3D::getBoundingBox() { float minX, minY, minZ; float maxX, maxY, maxZ; minX = minY = minZ = 10000000.0; maxX = maxY = maxZ = -10000000.0; for (int i = 0; i<3; i++) { if (minX > this->v[i].x()) minX = this->v[i].x(); if (minY > this->v[i].y()) minY = this->v[i].y(); if (minZ > this->v[i].z()) minZ = this->v[i].z(); if (maxX < this->v[i].x()) maxX = this->v[i].x(); if (maxY < this->v[i].y()) maxY = this->v[i].y(); if (maxZ < this->v[i].z()) maxZ = this->v[i].z(); } EigenVector3 minV(minX, minY, minZ); EigenVector3 maxV(maxX, maxY, maxZ); return BoundingBox3D(minV, maxV); }
bool BoundingCircle::isInside2D(const BoundingObject2D& bounding_obj) const { switch (bounding_obj.getObjectType()) { case BOX: return ( bounding_obj.minU() <= minU() && bounding_obj.maxU() >= maxU() && bounding_obj.minV() <= minV() && bounding_obj.maxV() >= maxV() ); case CIRCLE: return ( (position.distance(bounding_obj.centroid())+ ((const BoundingCircle&)bounding_obj).getRadius()) <= radius ); default: break; } return false; }
// ----------------------------------------------------------------------- // // // ROUTINE: CDebugLineFX::OnServerMessage // // PURPOSE: Read an update message from the server. // // ----------------------------------------------------------------------- // LTBOOL CDebugLineFX::OnServerMessage(ILTMessage_Read * pMsg) { // Read the number of lines. const int num_lines = pMsg->Readuint16(); // Set the new maximum number of lines m_nMaxLines = pMsg->Readuint32(); // See if the server is telling us to clear our old lines. m_bClearOldLines = (pMsg->Readuint8() != 0); #ifdef DEBUGLINEFX_DEBUG g_pLTClient->CPrint("Reading %d lines, clear lines is %s.", num_lines, m_bClearOldLines ? "true" : "false"); #endif // If we don't have any lines, we want to clear our old lines // so that the object will be re-positioned correctly. if( lines.empty() ) m_bClearOldLines = true; // Clear the lines from memory. The lines will be removed from // the line system in Update. if( m_bClearOldLines ) { #ifdef DEBUGLINEFX_DEBUG g_pLTClient->CPrint("Clearing %d lines.", lines.size()); #endif lines.clear(); } // Read each line. DebugLine new_line; LT_LINEF new_linef; LTVector maxV(0.0f,0.0f,0.0f); LTVector minV(0.0f,0.0f,0.0f); bool first = true; for(int i = 0; i < num_lines; ++i) { pMsg->ReadType(&new_line); new_linef.verts[0].x = new_line.vSource.x; new_linef.verts[0].y = new_line.vSource.y; new_linef.verts[0].z = new_line.vSource.z; new_linef.verts[1].x = new_line.vDest.x; new_linef.verts[1].y = new_line.vDest.y; new_linef.verts[1].z = new_line.vDest.z; new_linef.rgba.r = new_line.rgba.r; new_linef.rgba.g = new_line.rgba.g; new_linef.rgba.b = new_line.rgba.b; new_linef.rgba.a = new_line.rgba.a; lines.push_back( new_linef ); if (first) { first = false; maxV.x = Max(new_line.vSource.x,new_line.vDest.x); maxV.y = Max(new_line.vSource.y,new_line.vDest.y); maxV.z = Max(new_line.vSource.z,new_line.vDest.z); minV.x = Min(new_line.vSource.x,new_line.vDest.x); minV.y = Min(new_line.vSource.y,new_line.vDest.y); minV.z = Min(new_line.vSource.z,new_line.vDest.z); } else { maxV.x = Max(maxV.x,new_line.vSource.x); maxV.y = Max(maxV.y,new_line.vSource.y); maxV.z = Max(maxV.z,new_line.vSource.z); maxV.x = Max(maxV.x,new_line.vDest.x); maxV.y = Max(maxV.y,new_line.vDest.y); maxV.z = Max(maxV.z,new_line.vDest.z); minV.x = Min(minV.x,new_line.vSource.x); minV.y = Min(minV.y,new_line.vSource.y); minV.z = Min(minV.z,new_line.vSource.z); minV.x = Min(minV.x,new_line.vDest.x); minV.y = Min(minV.y,new_line.vDest.y); minV.z = Min(minV.z,new_line.vDest.z); } } char szDebugString[256]; pMsg->ReadString(szDebugString,sizeof(szDebugString)); m_pStr->SetText(szDebugString); if (num_lines) { vStrPos = (maxV + minV) / 2.0f; vStrPos.y += 16.0f; uint32 color = SET_ARGB(new_linef.rgba.a,new_linef.rgba.r,new_linef.rgba.g,new_linef.rgba.b); m_pStr->SetColor(color); } // Make sure the lines get updated. m_bUpdateLines = true; return LTTRUE; }
float UCBVHaarSingleStumpLearner::run() { if ( UCBVHaarSingleStumpLearner::_numOfCalling == 0 ) { init(); } UCBVHaarSingleStumpLearner::_numOfCalling++; //cout << "Num of iter:\t" << UCBVHaarSingleStumpLearner::_numOfCalling << " " << this->getTthSeriesElement( UCBVHaarSingleStumpLearner::_numOfCalling ) << flush << endl; const int numClasses = _pTrainingData->getNumClasses(); // set the smoothing value to avoid numerical problem // when theta=0. setSmoothingVal( 1.0 / (float)_pTrainingData->getNumExamples() * 0.01 ); vector<sRates> mu(numClasses); // The class-wise rates. See BaseLearner::sRates for more info. vector<float> tmpV(numClasses); // The class-wise votes/abstentions float tmpThreshold; float tmpAlpha; float bestEnergy = numeric_limits<float>::max(); float tmpEnergy; HaarData* pHaarData = static_cast<HaarData*>(_pTrainingData); // get the whole data matrix //const vector<int*>& intImages = pHaarData->getIntImageVector(); // The data matrix transformed into the feature's space vector< pair<int, float> > processedHaarData(_pTrainingData->getNumExamples()); // I need to prepare both type of sampling StumpAlgorithm<float> sAlgo(numClasses); sAlgo.initSearchLoop(_pTrainingData); float halfTheta; if ( _abstention == ABST_REAL || _abstention == ABST_CLASSWISE ) halfTheta = _theta/2.0; else halfTheta = 0; // The declared features types vector<HaarFeature*>& loadedFeatures = pHaarData->getLoadedFeatures(); // for every feature type vector<HaarFeature*>::iterator ftIt; //vector<HaarFeature*>::iterator maxftIt; vector<float> maxV( loadedFeatures.size() ); vector<int> maxKey( loadedFeatures.size() ); vector<int> maxNum( loadedFeatures.size() ); //claculate the Bk,s,t of the randomly chosen features int key = getKeyOfMaximalElement(); int featureIdx = (int) (key / 10); int featureType = (key % 10); //for (i = 0, ftIt = loadedFeatures.begin(); ftIt != loadedFeatures.end(); i++ ++ftIt) //*ftIt = loadedFeatures[ featureType ]; // just for readability //HaarFeature* pCurrFeature = *ftIt; HaarFeature* pCurrFeature = loadedFeatures[ featureType ]; if (_samplingType != ST_NO_SAMPLING) pCurrFeature->setAccessType(AT_RANDOM_SAMPLING); // Reset the iterator on the configurations. For random sampling // this clear the visited list pCurrFeature->loadConfigByNum( featureIdx ); if (_verbose > 1) cout << "Learning type " << pCurrFeature->getName() << ".." << flush; // transform the data from intImages to the feature's space pCurrFeature->fillHaarData( _pTrainingData->getExamples(), processedHaarData ); //pCurrFeature->fillHaarData(intImages, processedHaarData); // sort the examples in the new space by their coordinate sort( processedHaarData.begin(), processedHaarData.end(), nor_utils::comparePair<2, int, float, less<float> >() ); // find the optimal threshold tmpThreshold = sAlgo.findSingleThresholdWithInit(processedHaarData.begin(), processedHaarData.end(), _pTrainingData, halfTheta, &mu, &tmpV); tmpEnergy = getEnergy(mu, tmpAlpha, tmpV); // Store it in the current weak hypothesis. // note: I don't really like having so many temp variables // but the alternative would be a structure, which would need // to be inheritable to make things more consistent. But this would // make it less flexible. Therefore, I am still undecided. This // might change! _alpha = tmpAlpha; _v = tmpV; // I need to save the configuration because it changes within the object _selectedConfig = pCurrFeature->getCurrentConfig(); // I save the object because it contains the informations about the type, // the name, etc.. _pSelectedFeature = pCurrFeature; _threshold = tmpThreshold; bestEnergy = tmpEnergy; float edge = 0.0; for( vector<sRates>::iterator itR = mu.begin(); itR != mu.end(); itR++ ) edge += ( itR->rPls - itR->rMin ); //need to set the X value updateKeys( key, edge * edge ); if (!_pSelectedFeature) { cerr << "ERROR: No Haar Feature found. Something must be wrong!" << endl; exit(1); } else { if (_verbose > 1) cout << "Selected type: " << _pSelectedFeature->getName() << endl; } return bestEnergy; }
robot::robot(std::string filename,bool hideCollisionLinks,bool hideJoints,bool convexDecomposeNonConvexCollidables,bool createVisualIfNone,bool showConvexDecompositionDlg,bool centerAboveGround,bool makeModel,bool noSelfCollision,bool positionCtrl): filenameAndPath(filename) { printToConsole("URDF import operation started."); openFile(); readJoints(); readLinks(); readSensors(); createJoints(hideJoints,positionCtrl); createLinks(hideCollisionLinks,convexDecomposeNonConvexCollidables,createVisualIfNone,showConvexDecompositionDlg); createSensors(); std::vector<int> parentlessObjects; std::vector<int> allShapes; std::vector<int> allObjects; std::vector<int> allSensors; for (int i=0;i<int(vLinks.size());i++) { if (simGetObjectParent(vLinks[i]->nLinkVisual)==-1) parentlessObjects.push_back(vLinks[i]->nLinkVisual); allObjects.push_back(vLinks[i]->nLinkVisual); allShapes.push_back(vLinks[i]->nLinkVisual); if (vLinks[i]->nLinkCollision!=-1) { if (simGetObjectParent(vLinks[i]->nLinkCollision)==-1) parentlessObjects.push_back(vLinks[i]->nLinkCollision); allObjects.push_back(vLinks[i]->nLinkCollision); allShapes.push_back(vLinks[i]->nLinkCollision); } } for (int i=0;i<int(vJoints.size());i++) { if (vJoints[i]->nJoint!=-1) { if (simGetObjectParent(vJoints[i]->nJoint)==-1) parentlessObjects.push_back(vJoints[i]->nJoint); allObjects.push_back(vJoints[i]->nJoint); } } for (int i=0;i<int(vSensors.size());i++) { if (vSensors[i]->nSensor!=-1) { if (simGetObjectParent(vSensors[i]->nSensor)==-1) parentlessObjects.push_back(vSensors[i]->nSensor); allObjects.push_back(vSensors[i]->nSensor); allSensors.push_back(vSensors[i]->nSensor); } if (vSensors[i]->nSensorAux!=-1) { allObjects.push_back(vSensors[i]->nSensorAux); allSensors.push_back(vSensors[i]->nSensorAux); } } // If we want to alternate respondable mask: if (!noSelfCollision) { for (int i=0;i<int(parentlessObjects.size());i++) setLocalRespondableMaskCummulative_alternate(parentlessObjects[i],true); } // Now center the model: if (centerAboveGround) { bool firstValSet=false; C3Vector minV,maxV; for (int shNb=0;shNb<int(allShapes.size());shNb++) { float* vertices; int verticesSize; int* indices; int indicesSize; if (simGetShapeMesh(allShapes[shNb],&vertices,&verticesSize,&indices,&indicesSize,NULL)!=-1) { C7Vector tr; simGetObjectPosition(allShapes[shNb],-1,tr.X.data); C3Vector euler; simGetObjectOrientation(allShapes[shNb],-1,euler.data); tr.Q.setEulerAngles(euler); for (int i=0;i<verticesSize/3;i++) { C3Vector v(vertices+3*i); v*=tr; if (!firstValSet) { minV=v; maxV=v; firstValSet=true; } else { minV.keepMin(v); maxV.keepMax(v); } } simReleaseBuffer((char*)vertices); simReleaseBuffer((char*)indices); } } C3Vector shiftAmount((minV+maxV)*-0.5f); shiftAmount(2)+=(maxV(2)-minV(2))*0.5f; for (int i=0;i<int(parentlessObjects.size());i++) { C3Vector p; simGetObjectPosition(parentlessObjects[i],-1,p.data); p+=shiftAmount; simSetObjectPosition(parentlessObjects[i],-1,p.data); } } // Now create a model bounding box if that makes sense: if ((makeModel)&&(parentlessObjects.size()==1)) { int p=simGetModelProperty(parentlessObjects[0]); p|=sim_modelproperty_not_model; simSetModelProperty(parentlessObjects[0],p-sim_modelproperty_not_model); for (int i=0;i<int(allObjects.size());i++) { if (allObjects[i]!=parentlessObjects[0]) { int p=simGetObjectProperty(allObjects[i]); simSetObjectProperty(allObjects[i],p|sim_objectproperty_selectmodelbaseinstead); } } for (int i=0;i<int(allSensors.size());i++) { if (allSensors[i]!=parentlessObjects[0]) { int p=simGetObjectProperty(allSensors[i]); simSetObjectProperty(allSensors[i],p|sim_objectproperty_dontshowasinsidemodel); // sensors are usually large and it is ok if they do not appear as inside of the model bounding box! } } } // Now select all new objects: simRemoveObjectFromSelection(sim_handle_all,-1); for (int i=0;i<int(allObjects.size());i++) simAddObjectToSelection(sim_handle_single,allObjects[i]); printToConsole("URDF import operation finished.\n\n"); }
void remesh(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const Eigen::VectorXi &M, Eigen::MatrixXd &Vout, Eigen::MatrixXi &Fout, Eigen::VectorXi &Mout, double e_length) { // The boundary vertices. double zmin = 1e10; double zmax = -1e10; for (int i = 0; i < V.rows(); i++) { zmin = std::min(zmin, V(i, 2)); zmax = std::max(zmax, V(i, 2)); } Eigen::VectorXd minV = V.colwise().minCoeff(), maxV = V.colwise().maxCoeff(); // Compute average edge length. if (e_length <= 0) { e_length = avg_edgeLength(V, F, M); } // Convert to OpenMesh. TriangleMesh tri; IGLToOpenMesh(V, F, tri); // Do some more setup. tri.update_face_normals(); tri.update_vertex_normals(); tri.request_vertex_status(); tri.request_edge_status(); tri.request_face_status(); // Check all edges to see if they're protected or not. TriangleMesh::EIter e_it; for (e_it = tri.edges_begin(); e_it != tri.edges_end(); ++e_it) { // Get both vertices. TriangleMesh::VHandle v0 = tri.to_vertex_handle(tri.halfedge_handle(*e_it, 0)); TriangleMesh::VHandle v1 = tri.to_vertex_handle(tri.halfedge_handle(*e_it, 1)); // See if both are nonoriginal if (M(tri.data(v0).getOriginalIndex()) != GLOBAL::nonoriginal_marker && M(tri.data(v1).getOriginalIndex()) != GLOBAL::nonoriginal_marker) { tri.data(*e_it).setProtected(true); } // Also set vertices if they're original. if (M(tri.data(v0).getOriginalIndex()) != GLOBAL::nonoriginal_marker) { tri.data(v0).setProtected(true); } if (M(tri.data(v1).getOriginalIndex()) != GLOBAL::nonoriginal_marker) { tri.data(v1).setProtected(true); } } /* // Check for bad vertices. for (int i = 0; i < tri.n_vertices(); ++i) { TriangleMesh::VertexHandle vv = TriangleMesh::VertexHandle(i); const TriangleMesh::Point &pt = tMesh.point(vv); // Set statitonary if original marker set. if (M(tri.data(vv).getOriginalIndex()) == GLOBAL::original_marker) { } } */ // Then, do the remeshing--but only split long edge, collapse short edges, // and equalize valences. IsotropicRemeshing ir(e_length); //int types = ISOTROPIC_REMESHING_TYPES::SPLIT_LONG_EDGES | //ISOTROPIC_REMESHING_TYPES::COLLAPSE_SHORT_EDGES | //ISOTROPIC_REMESHING_TYPES::EQUALIZE_VALENCES | //ISOTROPIC_REMESHING_TYPES::AREA_EQUALIZATION; ir.setBoundingBox(TriangleMesh::Point(maxV(0), maxV(1), maxV(2)), TriangleMesh::Point(minV(0), minV(1), minV(2))); int types = ISOTROPIC_REMESHING_TYPES::EQUALIZE_VALENCES | ISOTROPIC_REMESHING_TYPES::AREA_EQUALIZATION; ir.remesh(&tri, 1, types); // Then, copy it all back. Eigen::VectorXi origIdx; OpenMeshToIGL(tri, Vout, Fout, origIdx); // Set the new markers as well. Mout.resize(Vout.rows()); for (int i = 0; i < Vout.rows(); ++i) { // If it doesn't correspond to a previous vertex, it's a "nonoriginal". if (origIdx(i) == -1) { Mout(i) = GLOBAL::nonoriginal_marker; } else { // Otherwise, it's the same marker as it was before. Mout(i) = M(origIdx(i)); int oidx = origIdx(i); double moved = ( V.row(oidx) - Vout.row(i) ).norm(); if ( moved > GLOBAL::EPS && M(oidx) != GLOBAL::nonoriginal_marker) { printf("point %d(m:%d new:%d) moved by %lf\n", oidx, M(oidx), i, moved); Mout(i) = 10; } } int oidx = origIdx(i); if (Vout(i, 2) - zmin < 0 || zmax - Vout(i, 2) < 0) { printf("point %d(%d) moved out of bounds! by %lf vs %lf,%lf (%le,%le)\n", oidx, M(oidx), Vout(i, 2), zmin, zmax, Vout(i,2) - zmin, zmax - Vout(i,2)); exit(1); } } }
void MVListBase::selectNext(uint direction,int count,ulong modifiers, ibool toTop) /**************************************************************************** * * Function: MVListBase::selectNext * Parameters: direction - Flags indicating the direction to move * count - Number of cells to move down * modifiers - Keyboard shift modifiers * toTop - True if the cell should be moved to the top * * Description: Adjusts the selection by the specified number of cells in * the specified direction. If the shift modifiers are set, * then the selection is extended. * ****************************************************************************/ { MVPoint oldCursor(cursor); int maxv = maxV(),minv = minV(); int maxh = maxH(),minh = minH(); if (direction & lsBelow) if ((cursor.y += count) > maxv) cursor.y = maxv; if (direction & lsAbove) if ((cursor.y -= count) < minv) cursor.y = minv; if (direction & lsRight) if ((cursor.x += count) > maxh) cursor.x = maxh; if (direction & lsLeft) if ((cursor.x -= count) < minh) cursor.x = minh; if (cursor != oldCursor || (flags & lsExtending)) { if ((flags & lsMultipleSelect) && (modifiers & mdShift)) { if (cursor == oldCursor) return; if (direction & lsLeft) { if (flags & lsExtendRight) { // We are currently extending in the opposite direction, // so clear all of the cells from the old cursor position // to one above the new cursor position. If the selection // is only one high, then turn off the extending flags. if (cursor.x <= selection.left()) { flags &= ~lsExtendHoriz; selection.right() = selection.left()+1; selection.left() = cursor.x; if (selection.left() != selection.right()-1) { flags |= lsExtendLeft; selectRange(selection); } } else selection.right() = cursor.x+1; clearRange(selection.right(),selection.top(), oldCursor.x+1,selection.bottom()); } else { // We are currently extending the selection in the same // direction, or have just started to extend the selection flags |= lsExtendLeft; selection.left() = cursor.x; selectRange(cursor.x,selection.top(), oldCursor.x,selection.bottom()); } } if (direction & lsRight) { if (flags & lsExtendLeft) { if (cursor.x >= selection.right()-1) { flags &= ~lsExtendHoriz; selection.left() = selection.right()-1; selection.right() = cursor.x+1; if (selection.left() != selection.right()-1) { flags |= lsExtendRight; selectRange(selection); } } else selection.left() = cursor.x; clearRange(oldCursor.x,selection.top(), selection.left(),selection.bottom()); } else { flags |= lsExtendRight; selection.right() = cursor.x+1; selectRange(oldCursor.x+1,selection.top(), cursor.x+1,selection.bottom()); } } if (direction & lsAbove) { if (flags & lsExtendDown) { if (cursor.y <= selection.top()) { flags &= ~lsExtendVert; selection.bottom() = selection.top()+1; selection.top() = cursor.y; if (selection.top() != selection.bottom()-1) { flags |= lsExtendUp; selectRange(selection); } } else selection.bottom() = cursor.y+1; clearRange(selection.left(),selection.bottom(), selection.right(),oldCursor.y+1); } else { flags |= lsExtendUp; selection.top() = cursor.y; selectRange(selection.left(),cursor.y, selection.right(),oldCursor.y); } } if (direction & lsBelow) { if (flags & lsExtendUp) { if (cursor.y >= selection.bottom()-1) { flags &= ~lsExtendVert; selection.top() = selection.bottom()-1; selection.bottom() = cursor.y+1; if (selection.top() != selection.bottom()-1) { flags |= lsExtendDown; selectRange(selection); } } else selection.top() = cursor.y; clearRange(selection.left(),oldCursor.y, selection.right(),selection.top()); } else { flags |= lsExtendDown; selection.bottom() = cursor.y+1; selectRange(selection.left(),oldCursor.y+1, selection.right(),cursor.y+1); } } dirtyCell(oldCursor); } else { // The selection is not being extended, so clear any previous // selection and turn extending off, and reselect the cell // under the cursor. flags &= ~lsExtending; if (!(flags & lsDisjointSelect)) { clearSelection(); selectCell(cursor); } else { dirtyCell(oldCursor); dirtyCell(cursor); } } MV_message(owner,evBroadcast,cmListCursorChanged,this); refresh(); } focusCurrent(toTop); }