void test() { SpectrumListSimplePtr simple(new SpectrumListSimple); const size_t spectrumCount = 10; for (size_t i=0; i<spectrumCount; i++) { simple->spectra.push_back(SpectrumPtr(new Spectrum)); Spectrum& s = *simple->spectra.back(); s.index = i; s.id = "scan=" + lexical_cast<string>(i); } // check MyWrapper shared_ptr<MyWrapper> wrapper(new MyWrapper(simple)); wrapper->verifySize(10); unit_assert(wrapper->size() == 10); for (size_t i=0; i<spectrumCount; i++) { string id = "scan=" + lexical_cast<string>(i); unit_assert(wrapper->find(id) == i); IndexList indexList = wrapper->findNameValue("scan", lexical_cast<string>(i)); unit_assert(indexList.size()==1 && indexList[0]==i); const SpectrumIdentity& identity = wrapper->spectrumIdentity(i); unit_assert(identity.id == id); SpectrumPtr s = wrapper->spectrum(i); unit_assert(s->id == id); } // check FilterWrapper shared_ptr<FilterWrapper> filterWrapper(new FilterWrapper(simple)); unit_assert(filterWrapper->size() == 5); for (size_t i=0; i<filterWrapper->size(); i++) { string id = "scan=" + lexical_cast<string>(i*2); string scanNumber = lexical_cast<string>(i*2); unit_assert(filterWrapper->find(id) == i); IndexList indexList = filterWrapper->findNameValue("scan", scanNumber); unit_assert(indexList.size()==1 && indexList[0]==i); const SpectrumIdentity& identity = filterWrapper->spectrumIdentity(i); unit_assert(identity.id == id); SpectrumPtr s = filterWrapper->spectrum(i); unit_assert(s->id == id); } }
void Sky::init(ID3D10Device* device, ID3D10ShaderResourceView* cubemap, float radius){ md3dDevice = device; mCubeMap = cubemap; mVertexType = 1; mTech = fx::SkyFX->GetTechniqueByName("SkyTech"); mfxWVPVar = fx::SkyFX->GetVariableByName("gWVP")->AsMatrix(); mfxWorldVar = fx::SkyFX->GetVariableByName("gWorld")->AsMatrix(); mfxCubeMapVar = fx::SkyFX->GetVariableByName("gCubeMap")->AsShaderResource(); std::vector<D3DXVECTOR3> vertices; IndexList indices; BuildGeoSphere(2, radius, vertices, indices); VertexList skyVerts(vertices.size()); for(size_t i = 0; i < vertices.size(); ++i){ // Scale on y-axis to turn into an ellipsoid to make a flatter Sky surface skyVerts[i].pos = 0.5f*vertices[i]; } mNumVertices = skyVerts.size(); GfxObj::buildVB(skyVerts); mNumIndices = (UINT)indices.size(); mNumFaces = mNumIndices*3; GfxObj::buildIB(indices); }
double scn::Ruler::GetCyclicCoeff(size_t indexOfNode) { IndexList edges; auto& distance = distance_sssp; distance.clear(); if(indexOfNode != UGraph::NaF) {//one vertex tie(edges, std::ignore) = graph->RemoveNode(indexOfNode); double sum = 0; for(auto head = edges.begin(); head != edges.end(); head++) { RunSPFA(*head); for(auto tail = head + 1; tail != edges.end(); tail++) { sum += 1.0 / static_cast<double>(distance[*tail] + 2); } } ///restore graph->AddEdge(graph->AddNode(indexOfNode), edges); return 2 * sum / static_cast<double>(edges.size() * (edges.size() - 1)); } else {//the whole network //copy node list IndexList nodes = graph->CopyIndexOfNodes(); double total_sum = 0; for(auto node = nodes.begin(); node != nodes.end(); node++) { tie(edges, std::ignore) = graph->RemoveNode(*node); double sum = 0; for(auto head = edges.begin(); head != edges.end(); head++) { RunSPFA(*head); for(auto tail = head + 1; tail != edges.end(); tail++) { sum += 1.0 / static_cast<double>(distance[*tail] + 2); } } ///restore, add node first, then add list of edges of this node graph->AddEdge(graph->AddNode(*node), edges); //accumulate total_sum += 2 * sum / static_cast<double>(edges.size() * (edges.size() - 1)); } return total_sum / static_cast<double>(graph->GetNumberOfNodes()); } }
inline void operator() (Lattice& L, IndexList& idx) { typedef typename Lattice::element element; for(int dim = 0; dim < idx.size(); ++dim) { sum += L(idx) * L.get_n_left(idx, dim); sum += L(idx) * L.get_n_right(idx, dim); } }
void Mesh::construct() { if (!m_material || !m_geometry) { return; } destruct(); glGenVertexArrays(1, &m_vertexArray); glBindVertexArray(m_vertexArray); // Fill vertex position data glGenBuffers(1, &m_vertexBuffer); glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer); VertexList vertices = m_geometry->vertices(); glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_STATIC_DRAW); glVertexAttribPointer((GLint)ShaderAttribute::VertexPosition, 3, GL_FLOAT, GL_FALSE, 0, bufferOffset(0)); glEnableVertexAttribArray((GLint)ShaderAttribute::VertexPosition); // Fill UV vertex data if (m_geometry->uvCount()) { glGenBuffers(1, &m_textureCoordinatesBuffer); glBindBuffer(GL_ARRAY_BUFFER, m_textureCoordinatesBuffer); UVList uvs = m_geometry->uvs(); glBufferData(GL_ARRAY_BUFFER, uvs.size() * sizeof(glm::vec2), uvs.data(), GL_STATIC_DRAW); glVertexAttribPointer((GLint)ShaderAttribute::VertexTextureCoordinates, 2, GL_FLOAT, GL_FALSE, 0, bufferOffset(0)); glEnableVertexAttribArray((GLint)ShaderAttribute::VertexTextureCoordinates); } // Fill vertex normal data if (m_geometry->normalCount()) { glGenBuffers(1, &m_vertexNormalsBuffer); glBindBuffer(GL_ARRAY_BUFFER, m_vertexNormalsBuffer); VertexList normals = m_geometry->normals(); glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(glm::vec3), normals.data(), GL_STATIC_DRAW); glVertexAttribPointer((GLint)ShaderAttribute::VertexNormals, 3, GL_FLOAT, GL_FALSE, 0, bufferOffset(0)); glEnableVertexAttribArray((GLint)ShaderAttribute::VertexNormals); } // Fill index buffer glGenBuffers(1, &m_indexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer); IndexList indices = m_geometry->indices(); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(uint32_t), indices.data(), GL_STATIC_DRAW); glBindVertexArray(0); m_dirty = false; }
inline void operator() (Lattice& L, IndexList& idx) { typename Lattice::element delta = 0; for(int dim = 0; dim < idx.size(); ++dim) { delta += L.get_n_left(idx, dim); delta += L.get_n_right(idx, dim); } L(idx) += delta; }
void medTestDbApp::handleNonPersistentDataImported() { CHECK_TEST_RESULT(importedIndex.isValid()); CHECK_TEST_RESULT(importedIndex.isValidForSeries()); const int persistentSourceId = 1; const int nonPersistentSourceId = 2; // Check freshly imported data exists. npDb = dataManager->controllerForDataSource(nonPersistentSourceId); CHECK_TEST_RESULT( npDb ); CHECK_TEST_RESULT(npDb->dataSourceId() == nonPersistentSourceId); CHECK_TEST_RESULT( !npDb->isPersistent() ); typedef QList<medDataIndex> IndexList; IndexList patients = npDb->patients(); qDebug() << "patient size:"<< patients.size(); CHECK_TEST_RESULT(patients.size() == 1); CHECK_TEST_RESULT(patients[0].patientId() == importedIndex.patientId()); IndexList studies = npDb->studies(patients[0]); CHECK_TEST_RESULT(studies.size() == 1); CHECK_TEST_RESULT(studies[0].studyId() == importedIndex.studyId()); IndexList series = npDb->series(studies[0]); CHECK_TEST_RESULT(series.size() == 1); CHECK_TEST_RESULT(series[0].seriesId() == importedIndex.seriesId()); // Ensure persistent DB is empty at first db = dataManager->controllerForDataSource(persistentSourceId); CHECK_TEST_RESULT( db ); CHECK_TEST_RESULT( db->patients().size() == 0 ); // Test import from non-Persistent to persistent //disconnect(dataManager); disconnect(dataManager, 0, this, 0); connect(dataManager, SIGNAL(dataAdded(const medDataIndex&)), this, SLOT(onPersistentDataImported(const medDataIndex&))); //TODO: reeanble this test when fixing supported extension bug, //and priority list! //dataManager->storeNonPersistentSingleDataToDatabase(importedIndex); //when reenabling, remove these two lines testResult = DTK_SUCCEED; exit(); }
//*************************************************************************************** // Name: Subdivide // Desc: Function subdivides every input triangle into four triangles of equal area. //*************************************************************************************** void Subdivide(VertexList& vertices, IndexList& indices) { VertexList vin = vertices; IndexList iin = indices; vertices.resize(0); indices.resize(0); // v1 // * // / \ // / \ // m0*-----*m1 // / \ / \ // / \ / \ // *-----*-----* // v0 m2 v2 UINT numTris = (UINT)iin.size()/3; for(UINT i = 0; i < numTris; ++i) { D3DXVECTOR3 v0 = vin[ iin[i*3+0] ]; D3DXVECTOR3 v1 = vin[ iin[i*3+1] ]; D3DXVECTOR3 v2 = vin[ iin[i*3+2] ]; D3DXVECTOR3 m0 = 0.5f*(v0 + v1); D3DXVECTOR3 m1 = 0.5f*(v1 + v2); D3DXVECTOR3 m2 = 0.5f*(v0 + v2); vertices.push_back(v0); // 0 vertices.push_back(v1); // 1 vertices.push_back(v2); // 2 vertices.push_back(m0); // 3 vertices.push_back(m1); // 4 vertices.push_back(m2); // 5 indices.push_back(i*6+0); indices.push_back(i*6+3); indices.push_back(i*6+5); indices.push_back(i*6+3); indices.push_back(i*6+4); indices.push_back(i*6+5); indices.push_back(i*6+5); indices.push_back(i*6+4); indices.push_back(i*6+2); indices.push_back(i*6+3); indices.push_back(i*6+1); indices.push_back(i*6+4); } }
void medTestDbApp::handlePersistentDataImported() { CHECK_TEST_RESULT( db->patients().size() == 1 ); CHECK_TEST_RESULT( npDb->patients().size() == 0 ); typedef QList<medDataIndex> IndexList; IndexList patients = db->patients(); CHECK_TEST_RESULT(patients.size() == 1); IndexList studies = db->studies(patients[0]); CHECK_TEST_RESULT(studies.size() == 1); IndexList series = db->series(studies[0]); CHECK_TEST_RESULT(series.size() == 1); const medDataIndex persImportedIndex = series[0]; this->processEvents(); // clear cache. dataManager->clearCache(); // Check data in db matches original. dtkSmartPointer<dtkAbstractData> testDataFromDb = dataManager->data( persImportedIndex ); CHECK_TEST_RESULT(testDataFromDb->identifier() == testData->identifier()); CHECK_TEST_RESULT(medMetaDataKeys::PatientName.getFirstValue(testDataFromDb) == medMetaDataKeys::PatientName.getFirstValue(testData)); // Check removing works ok - need to use synchronous version. //dataManager->removeData( persImportedIndex ); //this->processEvents(); medDatabaseRemover remover( persImportedIndex ); remover.run(); // Should be no patients now. patients = db->patients(); CHECK_TEST_RESULT(patients.size() == 0); //close db? medDatabaseController::instance()->closeConnection(); testResult = DTK_SUCCEED; exit(); }
double scn::GetRichClubCoeff(UGraph::pGraph graph,size_t degree) { IndexList setOfHighNode;//whose degree is greater than //argument degree for(auto node = graph->begin(); node != graph->end(); node++) { if(node->GetDegree() > degree) { setOfHighNode.push_back(*node); } } double sum = 0; for(auto one = setOfHighNode.begin(); one != setOfHighNode.end(); one++) { for(auto two = one + 1; two != setOfHighNode.end(); two++) { if(graph->HasEdge(*one, *two)) sum++; } } return 2 * sum / static_cast<double>(setOfHighNode.size() * (setOfHighNode.size() - 1)); }
void IndexArrayMapBuilder::addPolygon(const IndexList& indices) { const size_t count = indices.size(); IndexList polyIndices(0); polyIndices.reserve(3 * (count - 2)); for (size_t i = 0; i < count - 2; ++i) { polyIndices.push_back(indices[0]); polyIndices.push_back(indices[i + 1]); polyIndices.push_back(indices[i + 2]); } add(GL_TRIANGLES, polyIndices); }
// Add triangle strip to the group void GLC_PrimitiveGroup::addTrianglesStrip(const IndexList& input, GLC_uint id) { m_StripsIndex+= input; m_TrianglesStripSize= m_StripsIndex.size(); m_StripIndexSizes.append(static_cast<GLsizei>(input.size())); if (m_StripIndexOffseti.isEmpty()) { m_StripIndexOffseti.append(0); } int offset= m_StripIndexOffseti.last() + m_StripIndexSizes.last(); m_StripIndexOffseti.append(offset); // The strip id if (0 != id) m_StripsId.append(id); else Q_ASSERT(m_StripsId.isEmpty()); }
void Sky::Subdivide(std::vector<D3DXVECTOR3>& vertices, std::vector<DWORD>& indices) { VertexList vin = vertices; IndexList iin = indices; vertices.resize(0); indices.resize(0); UINT numTris = (UINT)iin.size()/3; for(UINT i = 0; i < numTris; ++i) { D3DXVECTOR3 v0 = vin[ iin[i*3+0] ]; D3DXVECTOR3 v1 = vin[ iin[i*3+1] ]; D3DXVECTOR3 v2 = vin[ iin[i*3+2] ]; D3DXVECTOR3 m0 = 0.5f*(v0 + v1); D3DXVECTOR3 m1 = 0.5f*(v1 + v2); D3DXVECTOR3 m2 = 0.5f*(v0 + v2); vertices.push_back(v0); // 0 vertices.push_back(v1); // 1 vertices.push_back(v2); // 2 vertices.push_back(m0); // 3 vertices.push_back(m1); // 4 vertices.push_back(m2); // 5 indices.push_back(i*6+0); indices.push_back(i*6+3); indices.push_back(i*6+5); indices.push_back(i*6+3); indices.push_back(i*6+4); indices.push_back(i*6+5); indices.push_back(i*6+5); indices.push_back(i*6+4); indices.push_back(i*6+2); indices.push_back(i*6+3); indices.push_back(i*6+1); indices.push_back(i*6+4); } }
// Add triangles Fan GLC_uint GLC_Mesh::addTrianglesFan(GLC_Material* pMaterial, const IndexList& indexList, const int lod, double accuracy) { GLC_uint groupId= setCurrentMaterial(pMaterial, lod, accuracy); Q_ASSERT(m_PrimitiveGroups.value(lod)->contains(groupId)); Q_ASSERT(!indexList.isEmpty()); GLC_uint id= 0; if (0 == lod) { id= m_NextPrimitiveLocalId++; } m_MeshData.trianglesAdded(lod, indexList.size() - 2); m_PrimitiveGroups.value(lod)->value(groupId)->addTrianglesFan(indexList, id); // Invalid the geometry m_GeometryIsValid = false; return id; }
void process_for_equations(Modelica::MMO_Class &mmo_class) { EquationList &equations = mmo_class.equations_ref().equations_ref(); EquationList new_equations; foreach_ (Equation &e, equations) { if (is<ForEq>(e)) { ForEq feq = boost::get<ForEq>(e); IndexList il = feq.range().indexes(); ERROR_UNLESS(il.size() == 1, "process_for_equations:\n" "forIndexList with more than 1 forIndex are not supported yet\n"); Index in = il.front(); Name variable = in.name(); OptExp ind = in.exp(); ERROR_UNLESS(ind, "for-equation's index with implicit range not supported yet\n"); Expression exp = ind.get(); ForIndexIterator *forIndexIter = NULL; if (is<Range>(exp)) { forIndexIter = new RangeIterator(get<Range>(exp),mmo_class.syms_ref()); } else if (is<Brace>(exp)) { forIndexIter = new BraceIterator(get<Brace>(exp),mmo_class.syms_ref()); } else { ERROR("For Iterator not supported"); } while (forIndexIter->hasNext()) { Real index_val = forIndexIter->next(); foreach_ (Equation eq, feq.elements()) new_equations.push_back(instantiate_equation(eq, variable, index_val, mmo_class.syms_ref())); } delete forIndexIter; } else { // Not a for eq new_equations.push_back(e); } } mmo_class.equations_ref().equations_ref()=new_equations; }
void TriStripVisitor::stripify(Geometry& geom) { if (geom.containsDeprecatedData()) geom.fixDeprecatedData(); if (osg::getBinding(geom.getNormalArray())==osg::Array::BIND_PER_PRIMITIVE_SET) return; if (osg::getBinding(geom.getColorArray())==osg::Array::BIND_PER_PRIMITIVE_SET) return; if (osg::getBinding(geom.getSecondaryColorArray())==osg::Array::BIND_PER_PRIMITIVE_SET) return; if (osg::getBinding(geom.getFogCoordArray())==osg::Array::BIND_PER_PRIMITIVE_SET) return; // no point tri stripping if we don't have enough vertices. if (!geom.getVertexArray() || geom.getVertexArray()->getNumElements()<3) return; // check for the existence of surface primitives unsigned int numSurfacePrimitives = 0; unsigned int numNonSurfacePrimitives = 0; Geometry::PrimitiveSetList& primitives = geom.getPrimitiveSetList(); Geometry::PrimitiveSetList::iterator itr; for(itr=primitives.begin(); itr!=primitives.end(); ++itr) { switch((*itr)->getMode()) { case(PrimitiveSet::TRIANGLES): case(PrimitiveSet::TRIANGLE_STRIP): case(PrimitiveSet::TRIANGLE_FAN): case(PrimitiveSet::QUADS): case(PrimitiveSet::QUAD_STRIP): case(PrimitiveSet::POLYGON): ++numSurfacePrimitives; break; default: ++numNonSurfacePrimitives; break; } } // nothitng to tri strip leave. if (!numSurfacePrimitives) return; // compute duplicate vertices typedef std::vector<unsigned int> IndexList; unsigned int numVertices = geom.getVertexArray()->getNumElements(); IndexList indices(numVertices); unsigned int i,j; for(i=0;i<numVertices;++i) { indices[i] = i; } VertexAttribComparitor arrayComparitor(geom); std::sort(indices.begin(),indices.end(),arrayComparitor); unsigned int lastUnique = 0; unsigned int numUnique = 1; unsigned int numDuplicate = 0; for(i=1;i<numVertices;++i) { if (arrayComparitor.compare(indices[lastUnique],indices[i])==0) { //std::cout<<" found duplicate "<<indices[lastUnique]<<" and "<<indices[i]<<std::endl; ++numDuplicate; } else { //std::cout<<" unique "<<indices[i]<<std::endl; lastUnique = i; ++numUnique; } } // std::cout<<" Number of duplicates "<<numDuplicate<<std::endl; // std::cout<<" Number of unique "<<numUnique<<std::endl; // std::cout<<" Total number of vertices required "<<numUnique<<" vs original "<<numVertices<<std::endl; // std::cout<<" % size "<<(float)numUnique/(float)numVertices*100.0f<<std::endl; IndexList remapDuplicatesToOrignals(numVertices); lastUnique = 0; for(i=1;i<numVertices;++i) { if (arrayComparitor.compare(indices[lastUnique],indices[i])!=0) { // found a new vertex entry, so previous run of duplicates needs // to be put together. unsigned int min_index = indices[lastUnique]; for(j=lastUnique+1;j<i;++j) { min_index = osg::minimum(min_index,indices[j]); } for(j=lastUnique;j<i;++j) { remapDuplicatesToOrignals[indices[j]]=min_index; } lastUnique = i; } } unsigned int min_index = indices[lastUnique]; for(j=lastUnique+1;j<i;++j) { min_index = osg::minimum(min_index,indices[j]); } for(j=lastUnique;j<i;++j) { remapDuplicatesToOrignals[indices[j]]=min_index; } // copy the arrays. IndexList finalMapping(numVertices); IndexList copyMapping; copyMapping.reserve(numUnique); unsigned int currentIndex=0; for(i=0;i<numVertices;++i) { if (remapDuplicatesToOrignals[i]==i) { finalMapping[i] = currentIndex; copyMapping.push_back(i); currentIndex++; } } for(i=0;i<numVertices;++i) { if (remapDuplicatesToOrignals[i]!=i) { finalMapping[i] = finalMapping[remapDuplicatesToOrignals[i]]; } } MyTriangleIndexFunctor taf; taf._remapIndices.swap(finalMapping); Geometry::PrimitiveSetList new_primitives; new_primitives.reserve(primitives.size()); for(itr=primitives.begin(); itr!=primitives.end(); ++itr) { switch((*itr)->getMode()) { case(PrimitiveSet::TRIANGLES): case(PrimitiveSet::TRIANGLE_STRIP): case(PrimitiveSet::TRIANGLE_FAN): case(PrimitiveSet::QUADS): case(PrimitiveSet::QUAD_STRIP): case(PrimitiveSet::POLYGON): (*itr)->accept(taf); break; default: new_primitives.push_back(*itr); break; } } float minimum_ratio_of_indices_to_unique_vertices = 1; float ratio_of_indices_to_unique_vertices = ((float)taf._in_indices.size()/(float)numUnique); OSG_INFO<<"TriStripVisitor::stripify(Geometry&): Number of indices"<<taf._in_indices.size()<<" numUnique"<< numUnique << std::endl; OSG_INFO<<"TriStripVisitor::stripify(Geometry&): ratio indices/numUnique"<< ratio_of_indices_to_unique_vertices << std::endl; // only tri strip if there is point in doing so. if (!taf._in_indices.empty() && ratio_of_indices_to_unique_vertices>=minimum_ratio_of_indices_to_unique_vertices) { OSG_INFO<<"TriStripVisitor::stripify(Geometry&): doing tri strip"<< std::endl; unsigned int in_numVertices = 0; for(triangle_stripper::indices::iterator itr=taf._in_indices.begin(); itr!=taf._in_indices.end(); ++itr) { if (*itr>in_numVertices) in_numVertices=*itr; } // the largest indice is in_numVertices, but indices start at 0 // so increment to give to the corrent number of verticies. ++in_numVertices; // remap any shared vertex attributes RemapArray ra(copyMapping); arrayComparitor.accept(ra); triangle_stripper::tri_stripper stripifier(taf._in_indices); stripifier.SetCacheSize(_cacheSize); stripifier.SetMinStripSize(_minStripSize); triangle_stripper::primitive_vector outPrimitives; stripifier.Strip(&outPrimitives); if (outPrimitives.empty()) { OSG_WARN<<"Error: TriStripVisitor::stripify(Geometry& geom) failed."<<std::endl; return; } triangle_stripper::primitive_vector::iterator pitr; if (_generateFourPointPrimitivesQuads) { OSG_INFO<<"Collecting all quads"<<std::endl; typedef triangle_stripper::primitive_vector::iterator prim_iterator; typedef std::multimap<unsigned int,prim_iterator> QuadMap; QuadMap quadMap; // pick out quads and place them in the quadMap, and also look for the max for(pitr=outPrimitives.begin(); pitr!=outPrimitives.end(); ++pitr) { if (pitr->Indices.size()==4) { std::swap(pitr->Indices[2],pitr->Indices[3]); unsigned int minValue = *(std::max_element(pitr->Indices.begin(),pitr->Indices.end())); quadMap.insert(QuadMap::value_type(minValue,pitr)); } } // handle the quads if (!quadMap.empty()) { IndexList indices; indices.reserve(4*quadMap.size()); // adds all the quads into the quad primitive, in ascending order // and the QuadMap stores the quad's in ascending order. for(QuadMap::iterator qitr=quadMap.begin(); qitr!=quadMap.end(); ++qitr) { pitr = qitr->second; unsigned int min_pos = 0; for(i=1;i<4;++i) { if (pitr->Indices[min_pos]>pitr->Indices[i]) min_pos = i; } indices.push_back(pitr->Indices[min_pos]); indices.push_back(pitr->Indices[(min_pos+1)%4]); indices.push_back(pitr->Indices[(min_pos+2)%4]); indices.push_back(pitr->Indices[(min_pos+3)%4]); } bool inOrder = true; unsigned int previousValue = indices.front(); for(IndexList::iterator qi_itr=indices.begin()+1; qi_itr!=indices.end() && inOrder; ++qi_itr) { inOrder = (previousValue+1)==*qi_itr; previousValue = *qi_itr; } if (inOrder) { new_primitives.push_back(new osg::DrawArrays(GL_QUADS,indices.front(),indices.size())); } else { unsigned int maxValue = *(std::max_element(indices.begin(),indices.end())); if (maxValue>=65536) { osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(GL_QUADS); std::copy(indices.begin(),indices.end(),std::back_inserter(*elements)); new_primitives.push_back(elements); } else { osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(GL_QUADS); std::copy(indices.begin(),indices.end(),std::back_inserter(*elements)); new_primitives.push_back(elements); } } } } // handle non quad primitives for(pitr=outPrimitives.begin(); pitr!=outPrimitives.end(); ++pitr) { if (!_generateFourPointPrimitivesQuads || pitr->Indices.size()!=4) { bool inOrder = true; unsigned int previousValue = pitr->Indices.front(); for(triangle_stripper::indices::iterator qi_itr=pitr->Indices.begin()+1; qi_itr!=pitr->Indices.end() && inOrder; ++qi_itr) { inOrder = (previousValue+1)==*qi_itr; previousValue = *qi_itr; } if (inOrder) { new_primitives.push_back(new osg::DrawArrays(pitr->Type,pitr->Indices.front(),pitr->Indices.size())); } else { unsigned int maxValue = *(std::max_element(pitr->Indices.begin(),pitr->Indices.end())); if (maxValue>=65536) { osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(pitr->Type); elements->reserve(pitr->Indices.size()); std::copy(pitr->Indices.begin(),pitr->Indices.end(),std::back_inserter(*elements)); new_primitives.push_back(elements); } else { osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(pitr->Type); elements->reserve(pitr->Indices.size()); std::copy(pitr->Indices.begin(),pitr->Indices.end(),std::back_inserter(*elements)); new_primitives.push_back(elements); } } } } geom.setPrimitiveSetList(new_primitives); #if 0 // debugging code for indentifying the tri-strips. osg::Vec4Array* colors = new osg::Vec4Array(new_primitives.size()); for(i=0;i<colors->size();++i) { (*colors)[i].set(((float)rand()/(float)RAND_MAX), ((float)rand()/(float)RAND_MAX), ((float)rand()/(float)RAND_MAX), 1.0f); } geom.setColorArray(colors); geom.setColorBinding(osg::Array::BIND_PER_PRIMITIVE_SET); #endif } else { OSG_INFO<<"TriStripVisitor::stripify(Geometry&): not doing tri strip *****************"<< std::endl; } }
void OutBuilding::build(float w, float h, float d){ VertexPNTList vertices; VertexPNT v; float width = w; float height = h; float depth = d; float thrirdwidth = w/3; float twothirdwidth = (2*w)/3; float twothirdheight = (2*h)/3; //Front v.normal = D3DXVECTOR3( 0.0f, 0.0f, -1.0f); v.pos = D3DXVECTOR3(0.0f, 0.0f, 0.0f); v.texC = D3DXVECTOR2(0.0,0.0); vertices.push_back(v); v.pos = D3DXVECTOR3(0.0f, height, 0.0f); v.texC = D3DXVECTOR2(0.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(thrirdwidth, height, 0.0f); v.texC = D3DXVECTOR2(0.4,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(thrirdwidth, 0.0f, 0.0f); v.texC = D3DXVECTOR2(0.4,0.0); vertices.push_back(v); v.pos = D3DXVECTOR3(thrirdwidth, twothirdheight, 0.0f); v.texC = D3DXVECTOR2(0.4,0.7); vertices.push_back(v); v.pos = D3DXVECTOR3(twothirdwidth, twothirdheight, 0.0f); v.texC = D3DXVECTOR2(0.8,0.7); vertices.push_back(v); v.pos = D3DXVECTOR3(twothirdwidth, height, 0.0f); v.texC = D3DXVECTOR2(0.8,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, height, 0.0f); v.texC = D3DXVECTOR2(1.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, 0.0f, 0.0f); v.texC = D3DXVECTOR2(1.0,0.0); vertices.push_back(v); v.pos = D3DXVECTOR3(twothirdwidth, 0.0f, 0.0f); v.texC = D3DXVECTOR2(0.8,0.0); vertices.push_back(v); //Left Face v.normal = D3DXVECTOR3( -1.0f, 0.0f, 0.0f); v.pos = D3DXVECTOR3(0.0f, 0.0f, 0.0f); v.texC = D3DXVECTOR2(0.0,0.0); vertices.push_back(v); v.pos = D3DXVECTOR3(0.0f, height, 0.0f); v.texC = D3DXVECTOR2(0.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(0.0f, height, depth); v.texC = D3DXVECTOR2(1.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(0.0f, 0.0f, depth); v.texC = D3DXVECTOR2(1.0,0.0); vertices.push_back(v); //Top v.normal = D3DXVECTOR3( 0.0f, 1.0f, 0.0f); v.pos = D3DXVECTOR3(0.0f, height, 0.0f); v.texC = D3DXVECTOR2(0.0,0.0); vertices.push_back(v); v.pos = D3DXVECTOR3(0.0f, height, depth); v.texC = D3DXVECTOR2(0.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, height, depth); v.texC = D3DXVECTOR2(1.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, height, 0.0f); v.texC = D3DXVECTOR2(1.0,0.0); vertices.push_back(v); //Right v.normal = D3DXVECTOR3( 1.0f, 0.0f, 0.0f); v.pos = D3DXVECTOR3(width, 0.0f, 0.0f); v.texC = D3DXVECTOR2(0.0,0.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, 0.0f, depth); v.texC = D3DXVECTOR2(0.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, height, depth); v.texC = D3DXVECTOR2(1.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, height, 0.0f); v.texC = D3DXVECTOR2(1.0,0.0); vertices.push_back(v); //Bottom v.normal = D3DXVECTOR3( 0.0f, -1.0f, 0.0f); v.pos = D3DXVECTOR3(0.0f, 0.0f, 0.0f); v.texC = D3DXVECTOR2(0.0,0.0); vertices.push_back(v); v.pos = D3DXVECTOR3(0.0f, 0.0f, depth); v.texC = D3DXVECTOR2(0.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, 0.0f, depth); v.texC = D3DXVECTOR2(1.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, 0.0f, 0.0f); v.texC = D3DXVECTOR2(1.0,0.0); vertices.push_back(v); //Back v.normal = D3DXVECTOR3( 0.0f, 0.0f, 1.0f); v.pos = D3DXVECTOR3(width, 0.0f, depth); v.texC = D3DXVECTOR2(0.0,0.0); vertices.push_back(v); v.pos = D3DXVECTOR3(width, height, depth); v.texC = D3DXVECTOR2(0.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(0.0f, height, depth); v.texC = D3DXVECTOR2(1.0,1.0); vertices.push_back(v); v.pos = D3DXVECTOR3(0.0f, 0.0f, depth); v.texC = D3DXVECTOR2(1.0,0.0); vertices.push_back(v); mNumVertices = (UINT)vertices.size(); buildVB(vertices); IndexList indices; indices.push_back(0); indices.push_back(1); indices.push_back(2); indices.push_back(2); indices.push_back(3); indices.push_back(0); indices.push_back(4); indices.push_back(2); indices.push_back(6); indices.push_back(6); indices.push_back(5); indices.push_back(4); indices.push_back(9); indices.push_back(6); indices.push_back(7); indices.push_back(7); indices.push_back(8); indices.push_back(9); indices.push_back(10); indices.push_back(13); indices.push_back(12); indices.push_back(12); indices.push_back(11); indices.push_back(10); indices.push_back(14); indices.push_back(15); indices.push_back(16); indices.push_back(16); indices.push_back(17); indices.push_back(14); indices.push_back(18); indices.push_back(21); indices.push_back(16); indices.push_back(16); indices.push_back(19); indices.push_back(18); indices.push_back(22); indices.push_back(25); indices.push_back(24); indices.push_back(24); indices.push_back(23); indices.push_back(22); indices.push_back(26); indices.push_back(27); indices.push_back(28); indices.push_back(28); indices.push_back(29); indices.push_back(26); mNumFaces = (UINT)indices.size()/3; mNumIndices = (UINT)indices.size(); buildIB(indices); }
void test(bool indexed) { if (os_) *os_ << "test(): indexed=\"" << boolalpha << indexed << "\"\n"; MSData tiny; examples::initializeTiny(tiny); Serializer_mzML::Config config; config.indexed = indexed; Serializer_mzML serializer(config); ostringstream oss; serializer.write(oss, tiny); if (os_) *os_ << "oss:\n" << oss.str() << endl; shared_ptr<istream> is(new istringstream(oss.str())); // dummy would normally be read in from file MSData dummy; ParamGroupPtr pg1(new ParamGroup); pg1->id = "CommonMS1SpectrumParams"; pg1->cvParams.push_back(MS_positive_scan); pg1->cvParams.push_back(MS_full_scan); dummy.paramGroupPtrs.push_back(pg1); ParamGroupPtr pg2(new ParamGroup); pg2->id = "CommonMS2SpectrumParams"; pg2->cvParams.push_back(MS_positive_scan); pg2->cvParams.push_back(MS_full_scan); dummy.paramGroupPtrs.push_back(pg2); // so we don't have any dangling references dummy.instrumentConfigurationPtrs.push_back(InstrumentConfigurationPtr(new InstrumentConfiguration("LCQDeca"))); dummy.dataProcessingPtrs.push_back(DataProcessingPtr(new DataProcessing("XcaliburProcessing"))); SpectrumListPtr sl = SpectrumList_mzML::create(is, dummy, indexed); // check easy functions unit_assert(sl.get()); unit_assert(sl->size() == 4); unit_assert(sl->find ("S19") == 0); unit_assert(sl->findNative("19") == 0); unit_assert(sl->find("S20") == 1); unit_assert(sl->findNative("20") == 1); unit_assert(sl->find("S21") == 2); unit_assert(sl->findNative("21") == 2); unit_assert(sl->find("S22") == 3); unit_assert(sl->findNative("22") == 3); unit_assert(sl->findSpotID("A1").empty()); IndexList spotIndexList = sl->findSpotID("A1,42x42,4242x4242"); unit_assert(spotIndexList.size() == 1); unit_assert(spotIndexList[0] == 3); // check scan 19 SpectrumPtr s = sl->spectrum(0); // read without binary data unit_assert(s.get()); unit_assert(s->id == "S19"); unit_assert(s->nativeID == "19"); unit_assert(s->spotID.empty()); unit_assert(s->cvParam(MS_ms_level).valueAs<int>() == 1); unit_assert(s->binaryDataArrayPtrs.empty()); unit_assert(sl->spectrumIdentity(0).index == 0); unit_assert(sl->spectrumIdentity(0).id == "S19"); unit_assert(sl->spectrumIdentity(0).nativeID == "19"); unit_assert(sl->spectrumIdentity(0).spotID.empty()); SpectrumPtr s_cache = sl->spectrum(0); // cache read unit_assert(s_cache.get() == s.get()); s = sl->spectrum(0, true); // read with binary data unit_assert(s_cache.get() != s.get()); vector<MZIntensityPair> pairs; s->getMZIntensityPairs(pairs); unit_assert(pairs.size() == 15); for (int i=0; i<15; i++) unit_assert(pairs[i].mz==i && pairs[i].intensity==15-i); unit_assert(s->spectrumDescription.scan.paramGroupPtrs.size() == 1); unit_assert(s->spectrumDescription.scan.paramGroupPtrs.back()->id == "CommonMS1SpectrumParams"); unit_assert(s->spectrumDescription.scan.paramGroupPtrs.back()->cvParams.size() == 2); // check scan 20 s = sl->spectrum(1, true); unit_assert(s.get()); unit_assert(s->id == "S20"); unit_assert(s->nativeID == "20"); unit_assert(s->spotID.empty()); unit_assert(s->cvParam(MS_ms_level).valueAs<int>() == 2); unit_assert(sl->spectrumIdentity(1).index == 1); unit_assert(sl->spectrumIdentity(1).id == "S20"); unit_assert(sl->spectrumIdentity(1).nativeID == "20"); unit_assert(sl->spectrumIdentity(1).spotID.empty()); pairs.clear(); s->getMZIntensityPairs(pairs); unit_assert(pairs.size() == 10); for (int i=0; i<10; i++) unit_assert(pairs[i].mz==2*i && pairs[i].intensity==(10-i)*2); unit_assert(s->spectrumDescription.scan.paramGroupPtrs.size() == 1); unit_assert(s->spectrumDescription.scan.paramGroupPtrs.back()->id == "CommonMS2SpectrumParams"); unit_assert(s->spectrumDescription.scan.paramGroupPtrs.back()->cvParams.size() == 2); // check scan 22 (MALDI) s = sl->spectrum(3, true); unit_assert(s.get()); unit_assert(s->id == "S22"); unit_assert(s->nativeID == "22"); unit_assert(s->spotID == "A1,42x42,4242x4242"); unit_assert(s->cvParam(MS_ms_level).valueAs<int>() == 1); unit_assert(sl->spectrumIdentity(3).index == 3); unit_assert(sl->spectrumIdentity(3).id == "S22"); unit_assert(sl->spectrumIdentity(3).nativeID == "22"); unit_assert(sl->spectrumIdentity(3).spotID == "A1,42x42,4242x4242"); }
void IndexArrayMapBuilder::add(const PrimType primType, const IndexList& indices) { const size_t offset = m_ranges.add(primType, indices.size()); IndexList::iterator dest = m_indices.begin(); std::advance(dest, offset); std::copy(indices.begin(), indices.end(), dest); }
void IndexArrayMapBuilder::addQuads(const IndexList& indices) { assert(indices.size() % 4 == 0); add(GL_QUADS, indices); }
void IndexArrayMapBuilder::addTriangles(const IndexList& indices) { assert(indices.size() % 3 == 0); add(GL_TRIANGLES, indices); }
void IndexArrayMapBuilder::addLines(const IndexList& indices) { assert(indices.size() % 2 == 0); add(GL_LINES, indices); }