void Foam::cyclicGgiPolyPatch::checkDefinition() const { // A little bit of sanity check The rotation angle/axis is // specified in both the master and slave patch of the // cyclicGgi. This is a pain, but the other alternatives // would be: // // - Specify in only of the two patches boundary // definition : - which one to chose? - which default // value to chose for the non-initialized value - Use a // specific dictionary for this... Nope, too cumbersome. // // So, we impose that the boundary definition of both // patches must specify the same information If not, well, // we stop the simulation and ask for a fix. if (!active()) { // No need to check anything, the shadow is not initialized properly. // This will happen with blockMesh when defining cyclicGGI patches. // Return quietly return; } if ( (mag(rotationAngle()) - mag(cyclicShadow().rotationAngle())) > SMALL || cmptSum(rotationAxis() - cyclicShadow().rotationAxis()) > SMALL ) { FatalErrorIn("void cyclicGgiPolyPatch::check() const") << " Rotation angle for patch name : " << name() << " is: " << rotationAngle() << " axis: " << rotationAxis() << nl << " Rotation angle for shadow patch name: " << shadowName() << " is: " << cyclicShadow().rotationAngle() << " axis: " << cyclicShadow().rotationAxis() << nl << " Both values need to be opposite in " << "the boundary file. " << abort(FatalError); } if ( (mag(separationOffset() + cyclicShadow().separationOffset())) > SMALL ) { FatalErrorIn("void cyclicGgiPolyPatch::check() const") << "Separation offset for patch name : " << name() << " is: " << separationOffset() << " Separation offset for shadow patch name: " << shadowName() << " is: " << cyclicShadow().separationOffset() << " axis: " << " Both values need to be opposite in " << "the boundary file. " << abort(FatalError); } if (debug > 1 && master()) { Info<< "Writing transformed slave patch as VTK." << nl << "Master: " << name() << " Slave: " << shadowName() << " Angle (master to slave): " << rotationAngle() << " deg" << " Axis: " << rotationAxis() << " Separation: " << separationOffset() << endl; const polyMesh& mesh = boundaryMesh().mesh(); fileName fvPath(mesh.time().path()/"VTK"); mkDir(fvPath); pointField transformedPoints = cyclicShadow().localPoints(); tensor rot = RodriguesRotation(rotationAxis_, -rotationAngle_); transform(transformedPoints, rot, transformedPoints); // Add separation offset to transformed points. HJ, 24/Nov/2009 transformedPoints += cyclicShadow().separationOffset(); standAlonePatch::writeVTK ( fvPath/fileName("cyclicGgi" + name() + cyclicShadow().name()), cyclicShadow().localFaces(), transformedPoints ); } }
Status ProjectionExec::transform(WorkingSetMember* member) const { if (_hasReturnKey) { BSONObj keyObj; if (member->hasComputed(WSM_INDEX_KEY)) { const IndexKeyComputedData* key = static_cast<const IndexKeyComputedData*>(member->getComputed(WSM_INDEX_KEY)); keyObj = key->getKey(); } member->state = WorkingSetMember::OWNED_OBJ; member->obj = keyObj; member->keyData.clear(); member->loc = DiskLoc(); return Status::OK(); } BSONObjBuilder bob; if (!requiresDocument()) { // Go field by field. if (_includeID) { BSONElement elt; // Sometimes the _id field doesn't exist... if (member->getFieldDotted("_id", &elt) && !elt.eoo()) { bob.appendAs(elt, "_id"); } } BSONObjIterator it(_source); while (it.more()) { BSONElement specElt = it.next(); if (mongoutils::str::equals("_id", specElt.fieldName())) { continue; } BSONElement keyElt; // We can project a field that doesn't exist. We just ignore it. if (member->getFieldDotted(specElt.fieldName(), &keyElt) && !keyElt.eoo()) { bob.appendAs(keyElt, specElt.fieldName()); } } } else { // Planner should have done this. verify(member->hasObj()); MatchDetails matchDetails; // If it's a positional projection we need a MatchDetails. if (transformRequiresDetails()) { matchDetails.requestElemMatchKey(); verify(NULL != _queryExpression); verify(_queryExpression->matchesBSON(member->obj, &matchDetails)); } Status projStatus = transform(member->obj, &bob, &matchDetails); if (!projStatus.isOK()) { return projStatus; } } for (MetaMap::const_iterator it = _meta.begin(); it != _meta.end(); ++it) { if (META_GEONEAR_DIST == it->second) { if (member->hasComputed(WSM_COMPUTED_GEO_DISTANCE)) { const GeoDistanceComputedData* dist = static_cast<const GeoDistanceComputedData*>( member->getComputed(WSM_COMPUTED_GEO_DISTANCE)); bob.append(it->first, dist->getDist()); } else { return Status(ErrorCodes::InternalError, "near loc dist requested but no data available"); } } else if (META_GEONEAR_POINT == it->second) { if (member->hasComputed(WSM_GEO_NEAR_POINT)) { const GeoNearPointComputedData* point = static_cast<const GeoNearPointComputedData*>( member->getComputed(WSM_GEO_NEAR_POINT)); BSONObj ptObj = point->getPoint(); if (ptObj.couldBeArray()) { bob.appendArray(it->first, ptObj); } else { bob.append(it->first, ptObj); } } else { return Status(ErrorCodes::InternalError, "near loc proj requested but no data available"); } } else if (META_TEXT_SCORE == it->second) { if (member->hasComputed(WSM_COMPUTED_TEXT_SCORE)) { const TextScoreComputedData* score = static_cast<const TextScoreComputedData*>( member->getComputed(WSM_COMPUTED_TEXT_SCORE)); bob.append(it->first, score->getScore()); } else { bob.append(it->first, 0.0); } } else if (META_DISKLOC == it->second) { bob.append(it->first, member->loc.toBSONObj()); } } BSONObj newObj = bob.obj(); member->state = WorkingSetMember::OWNED_OBJ; member->obj = newObj; member->keyData.clear(); member->loc = DiskLoc(); return Status::OK(); }
void CurrentApp::Update(float dt) { //Update the camera for movement m_camera->Update(dt); m_particleEmitter->update(dt); glm::vec3 pos = glm::vec3(100 * cos(CurrentTime() * 0.05f) + 150, 80, 100 * sin(CurrentTime() * 0.05f) + 150); m_fairyEmitter->SetPosition(pos); m_light->SetPosition(pos); for (int i = 0; i < 5; ++i) { m_AI[i]->update(dt); } Input* IM = Input::GetInstance(); glm::mat4 cameraWorld = m_camera->GetTransform(); PxVec3 displacement = PxVec3(0, 0, 0); bool notZero = false; bool m_canFly = false; if (IM->IsKeyDown('W')) { displacement -= PxVec3(cameraWorld[2].x, (m_canFly ? cameraWorld[2].y : 0), cameraWorld[2].z); notZero = true; } if (IM->IsKeyDown('A')) { displacement -= PxVec3(cameraWorld[0].x, (m_canFly ? cameraWorld[0].y : 0), cameraWorld[0].z); notZero = true; } if (IM->IsKeyDown('S')) { displacement += PxVec3(cameraWorld[2].x, (m_canFly ? cameraWorld[2].y : 0), cameraWorld[2].z); notZero = true; } if (IM->IsKeyDown('D')) { displacement += PxVec3(cameraWorld[0].x, (m_canFly ? cameraWorld[0].y : 0), cameraWorld[0].z); notZero = true; } if (notZero) displacement = displacement.getNormalized(); if (m_verticleSpeed > -10.0f && !m_canFly || m_verticleSpeed > 0 && m_canFly) m_verticleSpeed -= dt; displacement.y += m_verticleSpeed; PxControllerFilters filters; g_PlayerController->move(displacement, 0.01f, dt, filters); PxExtendedVec3 playerPos = g_PlayerController->getPosition(); PxExtendedVec3 footPos = g_PlayerController->getFootPosition(); //I do these calculations individually inside this vector constructor because PxEtendedVec3 doesn't contain some of the necessary operators to do this. vec3 endPos = vec3(2.0f * playerPos.x - footPos.x, 2.0f * playerPos.y - footPos.y, 2.0f * playerPos.z - footPos.z); m_camera->SetPosition(endPos); //Freeze the physics if (m_freezePhysics == false) { UpdatePhysx(dt); } else { UpdatePhysx(0); } //Generate new map if (Input::GetInstance()->IsKeyPressed('R')) { m_terrain->GenerateFromPerlin(); m_terrain->AddPhysicsShape(g_PhysicsScene, g_Physics); m_nodeMap->GenerateFromTerrain(m_terrain); m_world->Generate(); for (unsigned int i = 0; i < g_PhysXActors.size(); ++i) { PxTransform transform(PxVec3(150, 5 + (1.1f * i), 150)); g_PhysXActors[i]->setGlobalPose(transform); } } if (Input::GetInstance()->IsKeyPressed('N')) { m_nodeMap->GenerateFromTerrain(m_terrain); m_nodeMap->Draw(); } //Freeze Physics if (Input::GetInstance()->IsKeyPressed(GLFW_KEY_PAUSE)) { m_freezePhysics = !m_freezePhysics; } //Hide/Show Cursor if (Input::GetInstance()->IsKeyPressed(KEY_ESCAPE)) { glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL); } if (Input::GetInstance()->IsMousePressed(MOUSE_BUTTON_LEFT)) { glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); } //Deffered/Forward if (Input::GetInstance()->IsKeyPressed(KEY_F5)) { m_isDeffered = !m_isDeffered; } if (Input::GetInstance()->IsKeyPressed(KEY_F6)) { m_drawDebug = !m_drawDebug; } }
vector<T> operator-(vector<T> v) { transform(begin(v), end(v), begin(v), [](T n){ return -n; }); return v; }
void Foam::solidParticle::transformProperties (const tensor& T) { particle::transformProperties(T); U_ = transform(T, U_); }
inline string& Lower(string& str) { transform(str.begin(), str.end(), str.begin(), (int (*)(int))tolower); return str; }
IString IString::upperCase(){ std::string s = this->c_str(); transform( s.begin(), s.end(), s.begin(), ::toupper ); return IString(s.c_str()); }
void Path::translate(const FloatSize& size) { AffineTransform transformation; transformation.translate(size.width(), size.height()); transform(transformation); }
void starnt::dictionary::load(const std::wstring file) { if( !dict.empty()) if(file == dict_file) return; else dict.clear(); char* word; [&file, &word]()->void { #if defined _WIN32 HANDLE FileIn; FileIn = CreateFileW( file.c_str(),GENERIC_READ ,0,NULL,OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,NULL); if (FileIn == INVALID_HANDLE_VALUE) return; LARGE_INTEGER len; GetFileSizeEx(FileIn, &len); word = new char[len.LowPart + 1]; DWORD count; ReadFile(FileIn, word, len.LowPart, &count, NULL); if(count != len.LowPart) return; word[len.LowPart] = '\0'; CloseHandle(FileIn); #else // nix version #endif }(); //load individual words into strings std::pair<std::string, std::string> dict_entry; char* wordtok; wordtok = strtok(word, "\n"); for(int j = 0 ; wordtok != NULL ; j++ , wordtok = strtok(NULL, "\n")) { if(type == 1) { // encode dict_entry.first = wordtok; // the word transform(j, dict_entry.second); // code } else { //decode transform(j, dict_entry.first); // code dict_entry.second = wordtok; // the word } dict.insert( dict_entry ); } // replace LF with \0 /* for(size_t i=0; i < len ; i++) { while( (word[i] != '\n') && i < len) i++; word[i] = '\0'; } // then load individual words into strings std::pair<std::string, std::string> dict_entry; dict_entry.first= &word[0]; dict_entry.second = "a"; dict.insert( dict_entry ); for(int i = 2, j = 1 ; i < len ; i++,j++) { while(word[i] != '\0') i++; i++; if( i <len) { dict_entry.first = &word[i]; // the word dict_entry.second = transform(j); // code dict.insert( dict_entry ); } else break; } */ delete [] word; }
Matrix Matrix::rotation(Vec3f &rotation, Vec3f &pivot) { return transform(-pivot) * Matrix::rotation(rotation) * transform(pivot); }
void TestFunctors (void) { vector<int> v; v.resize (20); fill (v, 2); foreach (vector<int>::iterator, i, v) *i -= distance(v.begin(), i) & 1; vector<int> v1 (v); cout << "start:\t\t\t"; PrintVector (v); v = v1; cout << "plus:\t\t\t"; transform (v, v.begin(), v.begin(), plus<int>()); PrintVector (v); v = v1; cout << "minus:\t\t\t"; transform (v, v.begin(), v.begin(), minus<int>()); PrintVector (v); v = v1; cout << "divides:\t\t"; transform (v, v.begin(), v.begin(), divides<int>()); PrintVector (v); v = v1; cout << "multiplies:\t\t"; transform (v, v.begin(), v.begin(), multiplies<int>()); PrintVector (v); v = v1; cout << "modulus:\t\t"; transform (v, v.begin(), v.begin(), modulus<int>()); PrintVector (v); v = v1; cout << "logical_and:\t\t"; transform (v, v.begin(), v.begin(), logical_and<int>()); PrintVector (v); v = v1; cout << "logical_or:\t\t"; transform (v, v.begin(), v.begin(), logical_or<int>()); PrintVector (v); v = v1; cout << "equal_to:\t\t"; transform (v, v.begin(), v.begin(), equal_to<int>()); PrintVector (v); v = v1; cout << "not_equal_to:\t\t"; transform (v, v.begin(), v.begin(), not_equal_to<int>()); PrintVector (v); v = v1; cout << "greater:\t\t"; transform (v, v.begin(), v.begin(), greater<int>()); PrintVector (v); v = v1; cout << "less:\t\t\t"; transform (v, v.begin(), v.begin(), less<int>()); PrintVector (v); v = v1; cout << "greater_equal:\t\t"; transform (v, v.begin(), v.begin(), greater_equal<int>()); PrintVector (v); v = v1; cout << "less_equal:\t\t"; transform (v, v.begin(), v.begin(), less_equal<int>()); PrintVector (v); v = v1; cout << "compare:\t\t"; transform (v, v.begin(), v.begin(), compare<int>()); PrintVector (v); v = v1; cout << "negate:\t\t\t"; transform (v, negate<int>()); PrintVector (v); v = v1; cout << "logical_not:\t\t"; transform (v, logical_not<int>()); PrintVector (v); v = v1; cout << "unary_neg(negate):\t"; transform (v, unary_negator(negate<int>())); PrintVector (v); v = v1; cout << "binder1st(plus,5):\t"; transform (v, bind1st(plus<int>(), 5)); PrintVector (v); v = v1; cout << "binder2nd(minus,1):\t"; transform (v, bind2nd(minus<int>(), 1)); PrintVector (v); v = v1; cout << "compose1(-,+5):\t\t"; transform (v, compose1 (negate<int>(), bind2nd(plus<int>(), 5))); PrintVector (v); v = v1; cout << "compose1(-,-4):\t\t"; transform (v, compose1 (negate<int>(), bind2nd(minus<int>(), 4))); PrintVector (v); v = v1; cout << "compose2(/,+6,-4):\t"; transform (v, compose2 (divides<int>(), bind2nd(plus<int>(), 6), bind2nd(minus<int>(), 4))); PrintVector (v); cout << "mem_var(plus,6):\t"; vector<A> av; for (uoff_t i = 0; i < 20; ++ i) av.push_back (A(i)); transform (av, mem_var1(&A::m_v, bind2nd(plus<int>(), 6))); PrintVector (av); vector<A>::iterator found = find_if (av, mem_var_equal_to(&A::m_v, 14)); cout << "14 found at position " << found - av.begin() << endl; found = lower_bound (av.begin(), av.end(), 18, mem_var_less(&A::m_v)); cout << "18 found at position " << found - av.begin() << endl; cout << "add next:\t\t"; transform (av.begin(), av.end() - 1, av.begin() + 1, av.begin(), mem_var2(&A::m_v, plus<int>())); PrintVector (av); }
Matrix Matrix::transform(const Vec3f &offset) { return transform(offset.x, offset.y, offset.z); }
Matrix Matrix::scale(Vec3f &scale, Vec3f &pivot) { return transform(-pivot) * Matrix::scale(scale) * transform(pivot); }
void GraphicsLayerTextureMapper::commitLayerChanges() { if (m_changeMask == NoChanges) return; if (m_changeMask & ChildrenChange) m_layer.setChildren(children()); if (m_changeMask & MaskLayerChange) m_layer.setMaskLayer(&downcast<GraphicsLayerTextureMapper>(maskLayer())->layer()); if (m_changeMask & ReplicaLayerChange) m_layer.setReplicaLayer(&downcast<GraphicsLayerTextureMapper>(replicaLayer())->layer()); if (m_changeMask & PositionChange) m_layer.setPosition(position()); if (m_changeMask & AnchorPointChange) m_layer.setAnchorPoint(anchorPoint()); if (m_changeMask & SizeChange) m_layer.setSize(size()); if (m_changeMask & TransformChange) m_layer.setTransform(transform()); if (m_changeMask & ChildrenTransformChange) m_layer.setChildrenTransform(childrenTransform()); if (m_changeMask & Preserves3DChange) m_layer.setPreserves3D(preserves3D()); if (m_changeMask & ContentsRectChange) m_layer.setContentsRect(contentsRect()); if (m_changeMask & MasksToBoundsChange) m_layer.setMasksToBounds(masksToBounds()); if (m_changeMask & DrawsContentChange) m_layer.setDrawsContent(drawsContent()); if (m_changeMask & ContentsVisibleChange) m_layer.setContentsVisible(contentsAreVisible()); if (m_changeMask & ContentsOpaqueChange) m_layer.setContentsOpaque(contentsOpaque()); if (m_changeMask & BackfaceVisibilityChange) m_layer.setBackfaceVisibility(backfaceVisibility()); if (m_changeMask & OpacityChange) m_layer.setOpacity(opacity()); if (m_changeMask & BackgroundColorChange) m_layer.setSolidColor(m_solidColor); if (m_changeMask & FilterChange) m_layer.setFilters(filters()); if (m_changeMask & BackingStoreChange) m_layer.setBackingStore(m_backingStore); if (m_changeMask & DebugVisualsChange) m_layer.setDebugVisuals(isShowingDebugBorder(), debugBorderColor(), debugBorderWidth(), isShowingRepaintCounter()); if (m_changeMask & RepaintCountChange) m_layer.setRepaintCount(repaintCount()); if (m_changeMask & ContentChange) m_layer.setContentsLayer(platformLayer()); if (m_changeMask & AnimationChange) m_layer.setAnimations(m_animations); if (m_changeMask & AnimationStarted) client().notifyAnimationStarted(this, "", m_animationStartTime); if (m_changeMask & FixedToViewporChange) m_layer.setFixedToViewport(fixedToViewport()); if (m_changeMask & IsScrollableChange) m_layer.setIsScrollable(isScrollable()); if (m_changeMask & CommittedScrollOffsetChange) m_layer.didCommitScrollOffset(m_committedScrollOffset); m_changeMask = NoChanges; }
void CRegionalMetaModel::Predict( const REAL* prInputs, REAL* prOutputs ) { vector< CTrustRegion* >hitRegions; //best region or multiple region? FindTrustRegions( prInputs, hitRegions ); // FindBestRegion( prInputs, hitRegions ); int nOutputs = GetOutputs(); int nHitRegions = hitRegions.size(); //for each trusted regional model, predict the result to vcOutputs[i][1...nOutputs] vector< vector<REAL> > vcOutputs(nHitRegions); for( int i=0; i<nHitRegions; i++ ){ vcOutputs[i].resize( nOutputs ); CMetaModel* pModel = m_vcMetaModels[ hitRegions[i]->GetModelId() ]; pModel->Predict( prInputs, &vcOutputs[i][0] ); } int nInputs = GetInputs(); REAL rSumWeights = 0; vector< REAL > vcSum( nOutputs, 0.0 ); //modified on 02/012/05 using trust probability for( i=0; i<nHitRegions; i++ ){ ASSERT( nInputs==hitRegions[i]->m_ptCen.size() ); vector<REAL> vcDistSqr(nInputs, 0.0); vector<REAL> vcRadSqr(nInputs, 0.0); vector<REAL> vcProbs(nInputs,0.0); transform( prInputs, prInputs+nInputs, hitRegions[i]->m_ptCen.begin(), vcDistSqr.begin(), diff_sqr<REAL>() ); // cout<<"dist sqr:"; // copy( vcDistSqr.begin(), vcDistSqr.end(), ostream_iterator<REAL>(cout, " ") ); cout<<endl; transform( hitRegions[i]->m_vcRadius.begin(), hitRegions[i]->m_vcRadius.end(), hitRegions[i]->m_vcRadius.begin(), vcRadSqr.begin(), multiplies<REAL>() ); // cout<<"radius sqr:"; // copy( vcRadSqr.begin(), vcRadSqr.end(), ostream_iterator<REAL>(cout, " ") ); cout<<endl; transform( vcDistSqr.begin(), vcDistSqr.end(), vcRadSqr.begin(), vcProbs.begin(), divides<REAL>() ); // cout<<"probs :"; // copy( vcProbs.begin(), vcProbs.end(), ostream_iterator<REAL>(cout, " ") ); cout<<endl; REAL rProb = accumulate( vcProbs.begin(), vcProbs.end(), 0.0) / nInputs; rProb = max( 1-rProb, 0.0 ); cdump<<"prob "<<i<<" "<<rProb<<"\t"; REAL rWeight = rProb / hitRegions[i]->GetSphereRadius(); for( int j=0; j<nOutputs; j++ ){ vcSum[j] += vcOutputs[i][j]*rWeight; } rSumWeights += rWeight; } if( rSumWeights > 0 ){ transform( vcSum.begin(), vcSum.end(), vcSum.begin(), bind2nd(divides<REAL>(), rSumWeights) ); copy( vcSum.begin(), vcSum.end(), prOutputs ); }else{ copy( vcOutputs[0].begin(), vcOutputs[0].end(), prOutputs ); } //compute the average outputs according to inverse sphere radius /* vector< REAL > vcSum( nOutputs, 0.0 ); REAL rSumInvRadius = 0; for( i=0; i<nHitRegions; i++ ){ REAL rInvRadius = 1.0 / hitRegions[i]->GetSphereRadius(); for( int j=0; j<nOutputs; j++ ){ vcSum[j] += vcOutputs[i][j]*rInvRadius; } rSumInvRadius += rInvRadius; } transform( vcSum.begin(), vcSum.end(), vcSum.begin(), bind2nd(divides<REAL>(), rSumInvRadius) ); copy( vcSum.begin(), vcSum.end(), prOutputs ); */ cdump<<"pred..."<<nHitRegions<<" nets"<<endl; }
int main (int argc, const char * argv[]) { std::string listFileName, pcdFileName; std::string pcdFileFullName, shotFileFullName; std::string pcdFilePath, outputFileName, shotDir; std::string kernelType, kernelSize; fstream outputFile, listFile, shotFile; //argument processing if (argc < 5) { std::cout << "shotFeature: Extracts SHOT features from pdc file." << endl << "Usage:" << endl << "shotFeature listFile outputFile kernelSizeType kernelSize [loadPathPrefix] [saveDirectory]" << endl; std::cout << "listFile is the name of file that contains the list of input pointcloud files" << endl; std::cout << "outputFile is the name of file where the extracted features will be saved" << endl; std::cout << "kernelType : possible values are: metric , knn" << endl; std::cout << "kernelSize: size of the kernel, depending on the kernelType it might be either in cm for metric or k for knn" << endl; std::cout << "[loadPathPrefix]: path prefix for loading pcd files"; std::cout << "[saveDirectory]: path prefix of destination directory for saving individual feature files separately."; return 0; } listFileName = argv[1]; outputFileName = argv[2]; kernelType = argv[3]; kernelSize = argv[4]; if (argc > 5) { pcdFilePath = argv[5]; } if (argc > 6) { shotDir = argv[6]; } transform (kernelType.begin (), kernelType.end (), kernelType.begin (), (int(*)(int)) tolower); if ( (kernelType.compare("metric") != 0) && (kernelType.compare("knn") != 0) ) { cout << "Error: Invalid kernelType:" << kernelType << endl; return -1; } outputFile.open(outputFileName.c_str(), ios::out); listFile.open(listFileName.c_str(), ios::in); while (!listFile.eof()) { pcl::PointCloud<pcl::PointXYZ>::Ptr cloudIn (new pcl::PointCloud<pcl::PointXYZ>); pcl::SHOTEstimation<pcl::PointXYZ,pcl::Normal,pcl::SHOT> shotExtractor; pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> ne; pcl::KdTreeFLANN<pcl::PointXYZ>::Ptr tree (new pcl::KdTreeFLANN<pcl::PointXYZ> ()); pcl::KdTreeFLANN<pcl::PointXYZ>::Ptr tree2 (new pcl::KdTreeFLANN<pcl::PointXYZ> ()); pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal>); pcl::PointCloud<pcl::SHOT>::Ptr cloudShot (new pcl::PointCloud<pcl::SHOT> ()); listFile >> pcdFileName; cout << "Loading file:" << pcdFileName << endl; if (argc > 5) { pcdFileFullName = pcdFilePath + "/" + pcdFileName; } else { pcdFileFullName = pcdFileName; } //loading pcd file pcl::io::loadPCDFile (pcdFileFullName, *cloudIn); //estimating input normals cout << "calculating normal…" << endl; ne.setInputCloud (cloudIn); ne.setSearchMethod (tree); ne.setRadiusSearch (0.03);// Use all neighbors in a sphere of radius 3cm ne.compute (*cloud_normals); //extract shot features for the input cloud cout << "extracting shot features…" << endl; shotExtractor.setInputCloud (cloudIn); shotExtractor.setInputNormals(cloud_normals); shotExtractor.setSearchMethod(tree2); //if(kernelType.compare("metric")==0) shotExtractor.setRadiusSearch(atof(kernelSize.c_str())); //else //shotExtractor.setKSearch(atof(kernelSize.c_str())); shotExtractor.compute(*cloudShot); //save the result to the outputFile cout << "saving to file…" << endl; for(int i=0;i<cloudShot->size();i++) { for(int j=0;j<cloudShot->points[i].descriptor.size();j++) { outputFile << cloudShot->points[i].descriptor[j] << " "; } outputFile << endl; } if(argc>6)//save individual shot feature files in shotDir { shotFileFullName = shotDir + "/" + pcdFileName.substr(0,pcdFileName.size()-3) + "txt"; cout << "saving individual shot file:" << shotFileFullName << endl; shotFile.open(shotFileFullName.c_str(),ios::out); for(int i=0;i<cloudShot->size();i++) { for(int j=0;j<cloudShot->points[i].descriptor.size();j++) { shotFile << cloudShot->points[i].descriptor[j] << " "; } shotFile << endl; } shotFile.close(); } cout << " done" << endl; } listFile.close(); outputFile.close(); return 0; }
void InstruccionLlamadaAFuncion::validarSemantica() { /* Implementar lo de XML y Jar Hacer testing del jar en Lejos */ /*DENTRO DE FUNCIONES DECLARADAS*/ /*Ver si existe la funcion*/ vector<DeclaracionDeFuncion*> *tablaDeFunciones = Programa::obtenerInstancia()->tablaDeFunciones; DeclaracionDeFuncion* funcionDeclarada = Programa::obtenerInstancia()->existeEnTablaDeFunciones(this->identificador, lista_parametros); bool encontrado = false; if( funcionDeclarada ) { funcionDeclarada->validarSemantica(this->identificador, lista_parametros); encontrado = true; } /*DE LAS FUNCIONES BUILT-IN*/ transform(this->identificador->begin(), this->identificador->end(), this->identificador->begin(), ::tolower); Funcion *fun = Programa::obtenerInstancia()->existeFuncionIncorporada(*this->identificador, this->lista_parametros); // true -> Funcion Existe if( !encontrado ) // Validar que no se haya encontrado ya en las locales { encontrado = fun!=0; } if( fun!=0 ) { // Insertarlo a la tabla! Programa::obtenerInstancia()->agregarUsoDeFuncionATabla(*this->identificador, this->lista_parametros, fun); } /*No esta ni en locales ni built-in, buscarlo en xml*/ Tipo *agregado = Programa::obtenerInstancia()->existeFuncionEnXmls(*this->identificador,this->lista_parametros); if( agregado ) { encontrado = true; } if( !encontrado ) { stringstream error; error << "No existe llamada a funcion '"; error << *this->identificador; error << "' con los parametros("; /*Lista de los parametros */ error << parametrosATipos(); error << ")"; throw(ExcepcionLegus(error.str(),numeroDeLinea)); } if( obtenerSiguiente() != 0) { obtenerSiguiente()->validarSemantica(); } /*Siempre revisar que sea distnto de nulo por si es incorporada*/ if( funcionDeclarada != 0) { /*Primero ver si los parametros estan correctos! SHIET*/ /*Segundo validar que las instrucciones esten correctas!*/ Instruccion *instrucciones = funcionDeclarada->obtenerInstruccion(); if( instrucciones != 0) { instrucciones->validarSemantica(); } } }
void StitcherView::scaleScene(qreal new_scale){ if(new_scale * transform().m11() > 0.01 && new_scale * transform().m11() < 100){ scale(new_scale,new_scale); } }
/*! Redraw the liquid in thermometer pipe. \param painter Painter */ void QwtThermo::drawThermo( QPainter *painter ) { int alarm = 0, taval = 0; QRect fRect; QRect aRect; QRect bRect; int inverted = ( d_data->maxValue < d_data->minValue ); // // Determine if value exceeds alarm threshold. // Note: The alarm value is allowed to lie // outside the interval (minValue, maxValue). // if ( d_data->alarmEnabled ) { if ( inverted ) { alarm = ( ( d_data->alarmLevel >= d_data->maxValue ) && ( d_data->alarmLevel <= d_data->minValue ) && ( d_data->value >= d_data->alarmLevel ) ); } else { alarm = ( ( d_data->alarmLevel >= d_data->minValue ) && ( d_data->alarmLevel <= d_data->maxValue ) && ( d_data->value >= d_data->alarmLevel ) ); } } // // transform values // int tval = transform( d_data->value ); if ( alarm ) taval = transform( d_data->alarmLevel ); // // calculate recangles // if ( d_data->orientation == Qt::Horizontal ) { if ( inverted ) { bRect.setRect( d_data->thermoRect.x(), d_data->thermoRect.y(), tval - d_data->thermoRect.x(), d_data->thermoRect.height() ); if ( alarm ) { aRect.setRect( tval, d_data->thermoRect.y(), taval - tval + 1, d_data->thermoRect.height() ); fRect.setRect( taval + 1, d_data->thermoRect.y(), d_data->thermoRect.x() + d_data->thermoRect.width() - ( taval + 1 ), d_data->thermoRect.height() ); } else { fRect.setRect( tval, d_data->thermoRect.y(), d_data->thermoRect.x() + d_data->thermoRect.width() - tval, d_data->thermoRect.height() ); } } else { bRect.setRect( tval + 1, d_data->thermoRect.y(), d_data->thermoRect.width() - ( tval + 1 - d_data->thermoRect.x() ), d_data->thermoRect.height() ); if ( alarm ) { aRect.setRect( taval, d_data->thermoRect.y(), tval - taval + 1, d_data->thermoRect.height() ); fRect.setRect( d_data->thermoRect.x(), d_data->thermoRect.y(), taval - d_data->thermoRect.x(), d_data->thermoRect.height() ); } else { fRect.setRect( d_data->thermoRect.x(), d_data->thermoRect.y(), tval - d_data->thermoRect.x() + 1, d_data->thermoRect.height() ); } } } else // Qt::Vertical { if ( tval < d_data->thermoRect.y() ) tval = d_data->thermoRect.y(); else { if ( tval > d_data->thermoRect.y() + d_data->thermoRect.height() ) tval = d_data->thermoRect.y() + d_data->thermoRect.height(); } if ( inverted ) { bRect.setRect( d_data->thermoRect.x(), tval + 1, d_data->thermoRect.width(), d_data->thermoRect.height() - ( tval + 1 - d_data->thermoRect.y() ) ); if ( alarm ) { aRect.setRect( d_data->thermoRect.x(), taval, d_data->thermoRect.width(), tval - taval + 1 ); fRect.setRect( d_data->thermoRect.x(), d_data->thermoRect.y(), d_data->thermoRect.width(), taval - d_data->thermoRect.y() ); } else { fRect.setRect( d_data->thermoRect.x(), d_data->thermoRect.y(), d_data->thermoRect.width(), tval - d_data->thermoRect.y() + 1 ); } } else { bRect.setRect( d_data->thermoRect.x(), d_data->thermoRect.y(), d_data->thermoRect.width(), tval - d_data->thermoRect.y() ); if ( alarm ) { aRect.setRect( d_data->thermoRect.x(), tval, d_data->thermoRect.width(), taval - tval + 1 ); fRect.setRect( d_data->thermoRect.x(), taval + 1, d_data->thermoRect.width(), d_data->thermoRect.y() + d_data->thermoRect.height() - ( taval + 1 ) ); } else { fRect.setRect( d_data->thermoRect.x(), tval, d_data->thermoRect.width(), d_data->thermoRect.y() + d_data->thermoRect.height() - tval ); } } } // // paint thermometer // const QColor bgColor = palette().color( QPalette::Window ); painter->fillRect( bRect, bgColor ); if ( alarm ) painter->fillRect( aRect, d_data->alarmBrush ); painter->fillRect( fRect, d_data->fillBrush ); }
HashReturn Update(hashState *state, const BitSequence *data, DataLength databitlen) { int r; __m128i x0; __m128i x1; __m128i x2; __m128i x3; __m128i x4; __m128i x5; __m128i x6; __m128i x7; __m128i y0; __m128i y1; __m128i y2; __m128i y3; while (databitlen >= 8 && state->pos != 0) { ((unsigned char *) state->x)[state->pos / 8] ^= *data; data += 1; databitlen -= 8; state->pos += 8; if (state->pos == 8 * CUBEHASH_BLOCKBYTES) { transform(state,CUBEHASH_ROUNDS); state->pos = 0; } } x0 = state->x[0]; x1 = state->x[1]; x2 = state->x[2]; x3 = state->x[3]; x4 = state->x[4]; x5 = state->x[5]; x6 = state->x[6]; x7 = state->x[7]; while (databitlen >= 8 * CUBEHASH_BLOCKBYTES) { x0 = _mm_xor_si128(x0,_mm_set_epi32(0,0,0,(crypto_uint32) *(crypto_uint16 *) data)); data += CUBEHASH_BLOCKBYTES; databitlen -= 8 * CUBEHASH_BLOCKBYTES; for (r = 0;r < CUBEHASH_ROUNDS;++r) { x4 = _mm_add_epi32(x0,x4); x5 = _mm_add_epi32(x1,x5); x6 = _mm_add_epi32(x2,x6); x7 = _mm_add_epi32(x3,x7); y0 = x2; y1 = x3; y2 = x0; y3 = x1; x0 = _mm_xor_si128(_mm_slli_epi32(y0,7),_mm_srli_epi32(y0,25)); x1 = _mm_xor_si128(_mm_slli_epi32(y1,7),_mm_srli_epi32(y1,25)); x2 = _mm_xor_si128(_mm_slli_epi32(y2,7),_mm_srli_epi32(y2,25)); x3 = _mm_xor_si128(_mm_slli_epi32(y3,7),_mm_srli_epi32(y3,25)); x0 = _mm_xor_si128(x0,x4); x1 = _mm_xor_si128(x1,x5); x2 = _mm_xor_si128(x2,x6); x3 = _mm_xor_si128(x3,x7); x4 = _mm_shuffle_epi32(x4,0x4e); x5 = _mm_shuffle_epi32(x5,0x4e); x6 = _mm_shuffle_epi32(x6,0x4e); x7 = _mm_shuffle_epi32(x7,0x4e); x4 = _mm_add_epi32(x0,x4); x5 = _mm_add_epi32(x1,x5); x6 = _mm_add_epi32(x2,x6); x7 = _mm_add_epi32(x3,x7); y0 = x1; y1 = x0; y2 = x3; y3 = x2; x0 = _mm_xor_si128(_mm_slli_epi32(y0,11),_mm_srli_epi32(y0,21)); x1 = _mm_xor_si128(_mm_slli_epi32(y1,11),_mm_srli_epi32(y1,21)); x2 = _mm_xor_si128(_mm_slli_epi32(y2,11),_mm_srli_epi32(y2,21)); x3 = _mm_xor_si128(_mm_slli_epi32(y3,11),_mm_srli_epi32(y3,21)); x0 = _mm_xor_si128(x0,x4); x1 = _mm_xor_si128(x1,x5); x2 = _mm_xor_si128(x2,x6); x3 = _mm_xor_si128(x3,x7); x4 = _mm_shuffle_epi32(x4,0xb1); x5 = _mm_shuffle_epi32(x5,0xb1); x6 = _mm_shuffle_epi32(x6,0xb1); x7 = _mm_shuffle_epi32(x7,0xb1); } } state->x[0] = x0; state->x[1] = x1; state->x[2] = x2; state->x[3] = x3; state->x[4] = x4; state->x[5] = x5; state->x[6] = x6; state->x[7] = x7; while (databitlen >= 8) { ((unsigned char *) state->x)[state->pos / 8] ^= *data; data += 1; databitlen -= 8; state->pos += 8; if (state->pos == 8 * CUBEHASH_BLOCKBYTES) { transform(state,CUBEHASH_ROUNDS); state->pos = 0; } } if (databitlen > 0) { ((unsigned char *) state->x)[state->pos / 8] ^= *data; state->pos += databitlen; } return SUCCESS; }
void operator-=(vector<T> &l, const vector<T> &r) { transform(begin(l), end(l), begin(r), begin(l), minus<T>()); }
// Lowercase字符串. 使用lowercase转化字符. static void Lowercase(std::string* parameter) { transform(parameter->begin(), parameter->end(), parameter->begin(), tolower); }
ScColorTransform ScLcms2ColorMgmtEngineImpl::createProofingTransform(ScColorMgmtEngine& engine, const ScColorProfile& inputProfile , eColorFormat inputFormat, const ScColorProfile& outputProfile, eColorFormat outputFormat, const ScColorProfile& proofProfile , eRenderIntent renderIntent, eRenderIntent proofingIntent, long transformFlags) { ScColorTransform transform(NULL); if (inputProfile.isNull() || outputProfile.isNull()) return transform; int inputProfEngineID = inputProfile.engine().engineID(); int outputProfEngineID = outputProfile.engine().engineID(); int proofProfEngineID = proofProfile.engine().engineID(); if ((engine.engineID() != m_engineID) || (inputProfEngineID != m_engineID) || (outputProfEngineID != m_engineID) || (proofProfEngineID != m_engineID)) return transform; const ScLcms2ColorProfileImpl* lcmsInputProf = dynamic_cast<const ScLcms2ColorProfileImpl*>(inputProfile.data()); const ScLcms2ColorProfileImpl* lcmsOutputProf = dynamic_cast<const ScLcms2ColorProfileImpl*>(outputProfile.data()); const ScLcms2ColorProfileImpl* lcmsProofingProf = dynamic_cast<const ScLcms2ColorProfileImpl*>(proofProfile.data()); if (!lcmsInputProf || !lcmsOutputProf || !lcmsProofingProf) return transform; long strategyFlags = 0; if (m_strategy.useBlackPointCompensation) strategyFlags |= Ctf_BlackPointCompensation; if (m_strategy.useBlackPreservation) strategyFlags |= Ctf_BlackPreservation; ScColorTransformInfo transInfo; transInfo.inputProfile = inputProfile.productDescription(); transInfo.outputProfile = outputProfile.productDescription(); transInfo.proofingProfile = proofProfile.productDescription(); transInfo.inputFormat = inputFormat; transInfo.outputFormat = outputFormat; transInfo.renderIntent = renderIntent; transInfo.proofingIntent = proofingIntent; transInfo.flags = transformFlags | strategyFlags; cmsUInt32Number lcmsFlags = translateFlagsToLcmsFlags(transformFlags | strategyFlags); cmsUInt32Number lcmsInputFmt = translateFormatToLcmsFormat(inputFormat); cmsUInt32Number lcmsOutputFmt = translateFormatToLcmsFormat(outputFormat); int lcmsIntent = translateIntentToLcmsIntent(renderIntent); int lcmsPrfIntent = translateIntentToLcmsIntent(proofingIntent); if (transInfo.inputProfile != transInfo.proofingProfile) { if (transInfo.proofingProfile == transInfo.outputProfile) { transInfo.proofingIntent = Intent_Relative_Colorimetric; lcmsPrfIntent = translateIntentToLcmsIntent(Intent_Relative_Colorimetric); } transform = m_transformPool->findTransform(transInfo); if (transform.isNull()) { cmsHTRANSFORM hTransform = NULL; hTransform = cmsCreateProofingTransform(lcmsInputProf->m_profileHandle , lcmsInputFmt, lcmsOutputProf->m_profileHandle, lcmsOutputFmt, lcmsProofingProf->m_profileHandle, lcmsIntent, lcmsPrfIntent, lcmsFlags | cmsFLAGS_SOFTPROOFING); if (hTransform) { ScLcms2ColorTransformImpl* newTrans = new ScLcms2ColorTransformImpl(engine, hTransform); newTrans->setTransformInfo(transInfo); transform = ScColorTransform(dynamic_cast<ScColorTransformData*>(newTrans)); m_transformPool->addTransform(transform, true); } } } else { transformFlags &= (~Ctf_Softproofing); transformFlags &= (~Ctf_GamutCheck); lcmsFlags = translateFlagsToLcmsFlags(transformFlags | strategyFlags); transInfo.flags = transformFlags | strategyFlags; transInfo.renderIntent = proofingIntent; transInfo.proofingIntent = (eRenderIntent) 0; if (transInfo.inputProfile == transInfo.outputProfile) { lcmsFlags |= cmsFLAGS_NULLTRANSFORM; transInfo.inputProfile = QString(); transInfo.outputProfile = QString(); transInfo.proofingProfile = QString(); transInfo.renderIntent = (eRenderIntent) 0; transInfo.proofingIntent = (eRenderIntent) 0; transInfo.flags = 0; } transform = m_transformPool->findTransform(transInfo); if (transform.isNull()) { cmsHTRANSFORM hTransform = NULL; hTransform = cmsCreateTransform(lcmsInputProf->m_profileHandle , lcmsInputFmt, lcmsOutputProf->m_profileHandle, lcmsOutputFmt, lcmsPrfIntent, lcmsFlags | cmsFLAGS_LOWRESPRECALC); if (hTransform) { ScLcms2ColorTransformImpl* newTrans = new ScLcms2ColorTransformImpl(engine, hTransform); newTrans->setTransformInfo(transInfo); transform = ScColorTransform(dynamic_cast<ScColorTransformData*>(newTrans)); m_transformPool->addTransform(transform, true); } } } return transform; }
bool IniReader::read(std::istream & is) { // The current section IniSection * section = NULL; bool ok = true; bool readline = true; std::string str; // While lines remain to be extracted for(size_t line = 1; is.good(); line++) { // Get a line to process if(readline) { str.clear(); getline(is, str); } else { readline = true; } size_t start = str.find_first_not_of(WHITESPACE); if(start == std::string::npos) { // Empty line (only whitespace) continue; } if(str[start] == '#' || (start + 1 < str.length() && str[start] == '/' && str[start+1] == '/')) { // Whole line was commented, no need to do anything with it. Continue getting the next line continue; } // Section header if(str[start] == '[') { size_t end = str.find(']', start + 1); if(end == std::string::npos) { LogDebug("invalid header @ line " << line << ": " << str); end = str.find_first_not_of(ALPHANUM, start + 1); if(end == std::string::npos) { end = str.length(); } } std::string sectionName = str.substr(start + 1, end - start - 1); transform(sectionName.begin(), sectionName.end(), sectionName.begin(), ::tolower); LogDebug("found section: \"" << sectionName << "\""); section = §ions[sectionName]; // Ignoring rest of the line, not verifying that it's only whitespace / comment continue; } if(!section) { LogWarning << "Ignoring non-empty line " << line << " outside a section: " << str; ok = false; continue; } size_t nameEnd = str.find_first_not_of(ALPHANUM, start); if(nameEnd == std::string::npos) { ok = false; LogWarning << "Missing '=' separator @ line " << line << ": " << str; continue; } else if(nameEnd == start) { ok = false; LogWarning << "Empty key name @ line " << line << ": " << str; continue; } bool quoted = false; size_t separator = str.find_first_not_of(WHITESPACE, nameEnd); if(separator == std::string::npos || str[separator] != '=') { if(separator != std::string::npos && separator + 1 < str.length() && str[separator] == '"' && str[separator + 1] == '=') { LogDebug("found '\"=' instead of '=\"' @ line " << line << ": " << str); quoted = true; } else { ok = false; LogWarning << "Missing '=' separator @ line " << line << ": " << str; continue; } } size_t valueStart = str.find_first_not_of(WHITESPACE, separator + 1); if(valueStart == std::string::npos) { // Empty value. section->addKey(str.substr(start, nameEnd - start), std::string()); continue; } std::string key = str.substr(start, nameEnd - start); std::string value; if(quoted || str[valueStart] == '"') { valueStart++; size_t valueEnd = str.find_last_of('"'); arx_assert(valueEnd != std::string::npos); if(valueEnd < valueStart) { // The localisation files are broken (missing ending quote) // But the spanish localisation files hae erroneous newlines in some values LogDebug("invalid quoted value @ line " << line << ": " << str); valueEnd = str.find_last_not_of(WHITESPACE) + 1; arx_assert(valueEnd >= valueStart); value = str.substr(valueStart, valueEnd - valueStart); // Add following lines until we find either a terminating quote, // an empty or commented line, a new section or a new key for(; is.good(); line++) { str.clear(); getline(is, str); size_t start = str.find_first_not_of(WHITESPACE); if(start == std::string::npos) { // Empty line (only whitespace) break; } if(str[start] == '#' || (start + 1 < str.length() && str[start] == '/' && str[start+1] == '/')) { // Whole line was commented break; } if(str[start] == '[') { // New section line--, readline = false; break; } size_t nameEnd = str.find_first_not_of(ALPHANUM, start); if(nameEnd != std::string::npos && nameEnd != start) { size_t separator = str.find_first_not_of(WHITESPACE, nameEnd); if(separator != std::string::npos && str[separator] == '=') { // New key line--, readline = false; break; } } // Replace newlines with spaces! value += ' '; size_t valueEnd = str.find_last_of('"'); if(valueEnd != std::string::npos) { // End of multi-line value value += str.substr(start, valueEnd - start); break; } valueEnd = str.find_last_not_of(WHITESPACE) + 1; arx_assert(valueEnd > start); value += str.substr(start, valueEnd - start); } } else { value = str.substr(valueStart, valueEnd - valueStart); } } else { size_t valueEnd = str.find_last_not_of(WHITESPACE) + 1; arx_assert(valueEnd != std::string::npos); arx_assert(valueEnd >= valueStart); value = str.substr(valueStart, valueEnd - valueStart); } section->addKey(key, value); // Ignoring rest of the line, not verifying that it's only whitespace / comment } return ok; }
void GadgetTreeReader::iterate(gadget::Node* parent, libember::glow::GlowElementCollection* collection) { if (collection != nullptr) { auto const last = std::end(*collection); for(auto it = std::begin(*collection); it != last; ++it) { auto& child = *it; auto const type = ber::Type::fromTag(child.typeTag()); if (type.isApplicationDefined()) { if (type.value() == GlowType::Node) { auto& glownode = *dynamic_cast<GlowNode*>(&child); auto node = gadget::NodeFactory::createNode(parent, glownode.identifier()); node->setDescription(glownode.description()); node->setSchema(glownode.schemaIdentifiers()); iterate(node, glownode.children()); } else if (type.value() == GlowType::Parameter) { auto& glowparam = dynamic_cast<GlowParameter&>(child); auto identifier = glowparam.identifier(); auto paramtype = glowparam.effectiveType(); switch(paramtype.value()) { case libember::glow::ParameterType::Boolean: transform(gadget::ParameterFactory::create(parent, identifier, false), &glowparam); break; case libember::glow::ParameterType::Enum: transform(gadget::ParameterFactory::create(parent, identifier), &glowparam); break; case libember::glow::ParameterType::Integer: transform(gadget::ParameterFactory::create(parent, identifier, 0, 1000, 0), &glowparam); break; case libember::glow::ParameterType::Octets: break; case libember::glow::ParameterType::Real: transform(gadget::ParameterFactory::create(parent, identifier, 0.0, 1000.0, 0.0), &glowparam); break; case libember::glow::ParameterType::String: transform(gadget::ParameterFactory::create(parent, identifier, std::string("text")), &glowparam); break; case libember::glow::ParameterType::Trigger: break; default: volatile int x = paramtype.value(); break; } } } } } }
//--------------------------------------------------------------------------- void File_ApeTag::Data_Parse() { //If footer if (Element_Code==(int64u)-1) { HeaderFooter(); Finish("ApeTag"); return; } //Parsing Ztring Value; Get_UTF8(Element_Size, Value, "Value"); Element_Info(Value); //Filling transform(Key.begin(), Key.end(), Key.begin(), (int(*)(int))toupper); //(int(*)(int)) is a patch for unix if (Key=="ALBUM") Fill(Stream_General, 0, General_Album, Value); else if (Key=="ARTIST") Fill(Stream_General, 0, General_Performer, Value); else if (Key=="AUTHOR") Fill(Stream_General, 0, General_WrittenBy, Value); else if (Key=="BAND") Fill(Stream_General, 0, General_Performer, Value); else if (Key=="COMMENT") Fill(Stream_General, 0, General_Comment, Value); else if (Key=="COMMENTS") Fill(Stream_General, 0, General_Comment, Value); else if (Key=="COMPOSER") Fill(Stream_General, 0, General_Composer, Value); else if (Key=="CONTENTGROUP") Fill(Stream_General, 0, General_Genre, Value); else if (Key=="COPYRIGHT") Fill(Stream_General, 0, General_Copyright, Value); else if (Key=="DISK") { if (Value.find(_T("/"))!=Error) { Fill(Stream_General, 0, General_Part_Position_Total, Value.SubString(_T("/"), _T(""))); Fill(Stream_General, 0, General_Part_Position, Value.SubString(_T(""), _T("/"))); } else Fill(Stream_General, 0, General_Track_Position, Value); } else if (Key=="ENCODEDBY") Fill(Stream_General, 0, General_EncodedBy, Value); else if (Key=="GENRE") Fill(Stream_General, 0, General_Genre, Value); else if (Key=="ORIGARTIST") Fill(Stream_General, 0, General_Original_Performer, Value); else if (Key=="TITLE") Fill(Stream_General, 0, General_Title, Value); else if (Key=="TRACK") { if (Value.find(_T("/"))!=Error) { Fill(Stream_General, 0, General_Track_Position_Total, Value.SubString(_T("/"), _T(""))); Fill(Stream_General, 0, General_Track_Position, Value.SubString(_T(""), _T("/"))); } else Fill(Stream_General, 0, General_Track_Position, Value); } else if (Key=="UNSYNCEDLYRICS") Fill(Stream_General, 0, General_Lyrics, Value); else if (Key=="WWW") Fill(Stream_General, 0, General_Title_Url, Value); else if (Key=="YEAR") Fill(Stream_General, 0, General_Recorded_Date, Value); else if (Key=="CONTENT GROUP DESCRIPTION") Fill(Stream_General, 0, General_Title, Value); else if (Key=="ORIGINAL ALBUM/MOVIE/SHOW TITLE") Fill(Stream_General, 0, General_Original_Album, Value); else if (Key=="ORIGINAL ARTIST(S)/PERFORMER(S)") Fill(Stream_General, 0, General_Original_Performer, Value); else if (Key=="MP3GAIN_MINMAX") Fill(Stream_Audio, 0, "MP3Gain, Min/Max", Value); else if (Key=="MP3GAIN_UNDO") Fill(Stream_Audio, 0, "MP3Gain, Undo", Value); else if (Key=="REPLAYGAIN_TRACK_GAIN") Fill(Stream_Audio, 0, Audio_ReplayGain_Gain, Value.To_float64(), 2, true); else if (Key=="REPLAYGAIN_TRACK_PEAK") Fill(Stream_Audio, 0, Audio_ReplayGain_Peak, Value.To_float64(), 6, true); else Fill(Stream_General, 0, Key.c_str(), Value); }