// simple callback enabling packages on main doc int EnablePackageOnParentDocument(Model* m, SBMLErrorLog *, void* userdata) { if (m == NULL) return LIBSBML_OPERATION_FAILED; // pull information out of userdata disable_info * info = static_cast<disable_info*>(userdata); SBMLDocument *mainDoc = static_cast<SBMLDocument*>(info->doc); std::set<std::pair<std::string, std::string> > disabled = static_cast<std::set <std::pair <std::string, std::string> > >(info->disabledPkgs); if (mainDoc == NULL) return LIBSBML_OPERATION_FAILED; XMLNamespaces *mainNS = mainDoc->getSBMLNamespaces()->getNamespaces(); XMLNamespaces *ns = m->getSBMLNamespaces()->getNamespaces(); for (int i = 0; i < ns->getLength(); i++) { std::string nsURI = ns->getURI(i); std::string prefix = ns->getPrefix(i); if (prefix.empty() == true) { continue; } else if (mainNS->containsUri(nsURI) == false) { bool alreadyDisabled = false; for (set<pair<string, string> >::iterator pkg = disabled.begin(); pkg != disabled.end(); pkg++) { if ((*pkg).first == nsURI) { alreadyDisabled = true; break; } } // just in case if (m->getSBMLDocument() == NULL) { continue; } if (m->isPackageEnabled(prefix) == true) { mainNS->add(nsURI, prefix); mainDoc->enablePackage(nsURI, prefix, true); mainDoc->setPackageRequired(prefix, m->getSBMLDocument()->getPackageRequired(prefix)); // we also need to make sure that if m was a modelDefinition // that we enable the package on its parent model Model * parent = dynamic_cast<Model*>(m->getAncestorOfType(SBML_MODEL)); if (parent != NULL) { parent->enablePackageInternal(nsURI, prefix, true); } } else if (m->getSBMLDocument()->hasUnknownPackage(nsURI) == true) { // here we are dealing with an unknown package // need to decide whether to add the ns or not bool addNS = true; // if it was listed to be stripped do not add if (info->strippedPkgs.contains(prefix) == true) { addNS = false; } // if it has already been disabled do not add else if (alreadyDisabled == true) { addNS = false; } // if it is an unflattenable package and flags dicatate do not add else if (info->stripUnflattenable == true) { if (info->abortForRequiredOnly == false) { addNS = false; } else if (m->getSBMLDocument()->getPackageRequired(nsURI) == true) { addNS = false; } } if (addNS == true) { // we have an unknown package so we cannot enable it // but we do tell the parent doc about it mainNS->add(nsURI, prefix); mainDoc->addUnknownPackageRequired(nsURI, prefix, m->getSBMLDocument()->getPackageRequired(nsURI)); } } } } return LIBSBML_OPERATION_SUCCESS; }
/** @cond doxygenLibsbmlInternal */ int CompFlatteningConverter::performConversion() { int result = LIBSBML_OPERATION_FAILED; if (mDocument == NULL) { return LIBSBML_INVALID_OBJECT; } Model* mModel = mDocument->getModel(); if (mModel == NULL) { return LIBSBML_INVALID_OBJECT; } CompSBMLDocumentPlugin *plugin = (CompSBMLDocumentPlugin*)(mDocument->getPlugin("comp")); // if we don't have a comp model we are done already if (plugin == NULL) { return LIBSBML_OPERATION_SUCCESS; } // strip packages as instructed by user int success = stripPackages(); if (success != LIBSBML_OPERATION_SUCCESS) { return LIBSBML_OPERATION_FAILED; } // look at the document and work out the status of any remaining packages mPackageValues.clear(); analyseDocument(); bool canFlatten = canBeFlattened(); if (canFlatten == false) { return LIBSBML_OPERATION_FAILED; } /* strip any unflattenable packages before we run validation */ if (getStripUnflattenablePackages() == true) { stripUnflattenablePackages(); } /* run the comp validation rules as flattening will fail * if there are bad or missing references between elements */ if (getPerformValidation() == true) { result = validateOriginalDocument(); if (result != LIBSBML_OPERATION_SUCCESS) { return result; } } CompModelPlugin *modelPlugin = (CompModelPlugin*)(mModel->getPlugin("comp")); if (modelPlugin==NULL) { restoreNamespaces(); return LIBSBML_OPERATION_FAILED; } mDocument->getErrorLog()->logPackageError("comp", CompModelFlatteningFailed, modelPlugin->getPackageVersion(), mDocument->getLevel(), mDocument->getVersion(), "The subsequent errors are from this attempt."); // setup callback that will enable the packages on submodels disable_info mainDoc; mainDoc.doc = mDocument; mainDoc.strippedPkgs = getPackagesToStrip(); mainDoc.disabledPkgs = mDisabledPackages; mainDoc.stripUnflattenable = getStripUnflattenablePackages(); mainDoc.abortForRequiredOnly = getAbortForRequired(); Submodel::addProcessingCallback(&EnablePackageOnParentDocument, &(mainDoc)); Model* flatmodel = modelPlugin->flattenModel(); if (flatmodel == NULL) { //'flattenModel' sets its own error messages. restoreNamespaces(); return LIBSBML_OPERATION_FAILED; } // we haven't failed flattening so remove that error message mDocument->getErrorLog()->remove(CompModelFlatteningFailed); if (getPerformValidation() == true) { flatmodel->populateAllElementIdList(); flatmodel->populateAllElementMetaIdList(); result = validateFlatDocument(flatmodel, modelPlugin->getPackageVersion(), modelPlugin->getLevel(), modelPlugin->getVersion()); if (result != LIBSBML_OPERATION_SUCCESS) { delete flatmodel; return result; } } // now reconstruct the document to be returned // taking user options into account result = reconstructDocument(flatmodel); delete flatmodel; if (result != LIBSBML_OPERATION_SUCCESS) { restoreNamespaces(); return result; } return LIBSBML_OPERATION_SUCCESS; }
void Benchmarker::benchmark(int N, const Action6D::ActionSet &actionSet) { assert(environment_ != nullptr); std::cout << "\t *** BEGIN BENCHMARKING ***" << std::endl; MPVec3 halfSize = MPVec3MultiplyScalar(environment_->getSize(), 0.5f); MPVec3 min = MPVec3Subtract(environment_->getOrigin(), halfSize); MPVec3 max = MPVec3Add(environment_->getOrigin(), halfSize); MPAABox environmentBounds = MPAABoxMake(min, max); // Randomly generate N start/goal pairs within the bounds of the environment generateRandomStartGoalPairs3D(N, environmentBounds); if(planner_ != nullptr) { delete planner_; planner_ = nullptr; } // Set the action set to be in 3D Model *activeObject = environment_->getActiveObject(); activeObject->setActionSet(actionSet); // Instantiate the planner planner_ = new AStarPlanner<Transform3D>(environment_, manhattanHeuristic); std::vector<std::vector<float> > planningTimes; std::vector<int> successes; // Test the planner with various weights for(int step = 0; step < 8; ++step) { int w; if(step < 2) w = step; else w = 2*step - 2; static_cast<AStarPlanner<Transform3D> *>(planner_)->setWeight(1.0f * w); std::cout << "\t *** WEIGHT = " << w << " ***" << std::endl; Timer timer; planningTimes.push_back(std::vector<float>()); double planningTime = 0.0f; int success = 0, failure = 0; std::vector<Transform3D> plan; for(int i = 0; i < N; ++i) { planCounter_ = (step + 1) * i; plan.clear(); std::cout << "Start: (" << startGoalPairs_.at(i).first.getPosition().x << ", " << startGoalPairs_.at(i).first.getPosition().y << ", " << startGoalPairs_.at(i).first.getPosition().z << "), Goal: (" << startGoalPairs_.at(i).second.getPosition().x << ", " << startGoalPairs_.at(i).second.getPosition().y << ", " << startGoalPairs_.at(i).second.getPosition().z << ")" << std::endl; // Reset the environment before each plan environment_->reset(); timer.start(); // Give the planner a timeout, and then force it to stop Later stopPlanner(PLANNER_TIMEOUT * 1000.0f, true, &Benchmarker::stopPlanning, this, (step + 1) * i); if(planner_->plan(startGoalPairs_.at(i).first, startGoalPairs_.at(i).second, plan)) { planningTime = (GET_ELAPSED_MICRO(timer) / 1000000.0f); std::cout << "Success! Plan took " << planningTime << " seconds " << std::endl; success++; } else { std::cout << "Plan failed :(" << std::endl; failure++; } planningTimes.at(step).push_back(planningTime); } std::cout << "\t *** TEST DONE ***" << std::endl; std::cout << success << " succeeded plans, " << failure << " failed plans" << std::endl;; std::cout << "Success rate: " << (1.0f * success / N) * 100.0f << "%" << std::endl; successes.push_back(success); } std::cout << "\t *** SUMMARY ***" << std::endl; for(int i = 0; i < planningTimes.size(); ++i) { float totalTime = 0.0f; int n = 0; for(auto time : planningTimes.at(i)) { if(time <= PLANNER_TIMEOUT) { totalTime += time; n++; } } int weight = (i < 2 ? i : 2*i - 2); std::cout << "Weight " << weight << ": (average) " << totalTime / n << " (success rate) " << ((1.0f * successes.at(i)) / N) * 100.0f << "%" << std::endl; } }
void ModelViewer::Startup( void ) { m_RootSig.Reset(6, 2); m_RootSig.InitStaticSampler(0, SamplerAnisoWrapDesc, D3D12_SHADER_VISIBILITY_PIXEL); m_RootSig.InitStaticSampler(1, SamplerShadowDesc, D3D12_SHADER_VISIBILITY_PIXEL); m_RootSig[0].InitAsConstantBuffer(0, D3D12_SHADER_VISIBILITY_VERTEX); m_RootSig[1].InitAsConstantBuffer(0, D3D12_SHADER_VISIBILITY_PIXEL); #if USE_ROOT_BUFFER_SRV || USE_VERTEX_BUFFER m_RootSig[2].InitAsBufferSRV(0, D3D12_SHADER_VISIBILITY_VERTEX); #else m_RootSig[2].InitAsDescriptorRange(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 1, D3D12_SHADER_VISIBILITY_VERTEX); #endif m_RootSig[3].InitAsDescriptorRange(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 6, D3D12_SHADER_VISIBILITY_PIXEL); m_RootSig[4].InitAsDescriptorRange(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 64, 3, D3D12_SHADER_VISIBILITY_PIXEL); m_RootSig[5].InitAsConstants(1, 1, D3D12_SHADER_VISIBILITY_VERTEX); #if USE_VERTEX_BUFFER m_RootSig.Finalize(D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT); #else m_RootSig.Finalize(); #endif DXGI_FORMAT ColorFormat = g_SceneColorBuffer.GetFormat(); DXGI_FORMAT DepthFormat = g_SceneDepthBuffer.GetFormat(); DXGI_FORMAT ShadowFormat = g_ShadowBuffer.GetFormat(); #if USE_VERTEX_BUFFER D3D12_INPUT_ELEMENT_DESC vertElem[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, { "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, { "BITANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 } }; #endif m_DepthPSO.SetRootSignature(m_RootSig); m_DepthPSO.SetRasterizerState(RasterizerDefault); m_DepthPSO.SetBlendState(BlendNoColorWrite); m_DepthPSO.SetDepthStencilState(DepthStateReadWrite); #if USE_VERTEX_BUFFER m_DepthPSO.SetInputLayout(_countof(vertElem), vertElem); #endif m_DepthPSO.SetPrimitiveTopologyType(D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE); m_DepthPSO.SetRenderTargetFormats(0, nullptr, DepthFormat); m_DepthPSO.SetVertexShader(g_pDepthViewerVS, sizeof(g_pDepthViewerVS)); m_DepthPSO.SetPixelShader(g_pDepthViewerPS, sizeof(g_pDepthViewerPS)); m_DepthPSO.Finalize(); m_ShadowPSO = m_DepthPSO; m_ShadowPSO.SetRasterizerState(RasterizerShadow); m_ShadowPSO.SetRenderTargetFormats(0, nullptr, g_ShadowBuffer.GetFormat()); m_ShadowPSO.Finalize(); m_ModelPSO = m_DepthPSO; m_ModelPSO.SetBlendState(BlendDisable); m_ModelPSO.SetDepthStencilState(DepthStateTestEqual); m_ModelPSO.SetRenderTargetFormats(1, &ColorFormat, DepthFormat); m_ModelPSO.SetVertexShader( g_pModelViewerVS, sizeof(g_pModelViewerVS) ); m_ModelPSO.SetPixelShader( g_pModelViewerPS, sizeof(g_pModelViewerPS) ); m_ModelPSO.Finalize(); m_ExtraTextures[0] = g_SSAOFullScreen.GetSRV(); m_ExtraTextures[1] = g_ShadowBuffer.GetSRV(); TextureManager::Initialize(L"Textures/"); ASSERT(m_Model.Load("Models/sponza.h3d"), "Failed to load model"); ASSERT(m_Model.m_Header.meshCount > 0, "Model contains no meshes"); CreateParticleEffects(); float modelRadius = Length(m_Model.m_Header.boundingBox.max - m_Model.m_Header.boundingBox.min) * .5f; const Vector3 eye = (m_Model.m_Header.boundingBox.min + m_Model.m_Header.boundingBox.max) * .5f + Vector3(modelRadius * .5f, 0.0f, 0.0f); m_Camera.SetEyeAtUp( eye, Vector3(kZero), Vector3(kYUnitVector) ); m_Camera.SetZRange( 1.0f, 10000.0f ); m_pCameraController = new CameraController(m_Camera, Vector3(kYUnitVector)); MotionBlur::Enable = true; TemporalAA::Enable = true; FXAA::Enable = true; PostEffects::EnableHDR = true; PostEffects::EnableAdaptation = true; PostEffects::AdaptationRate = 0.05f; PostEffects::TargetLuminance = 0.4f; PostEffects::MinExposure = 1.0f; PostEffects::MaxExposure = 8.0f; PostEffects::BloomThreshold = 1.0f; PostEffects::BloomStrength = 0.10f; }
/** * Tests whether the ForwarTranslator will handle the name of the GeneratorMicroTurbine correctly in the PlantEquipmentOperationHeatingLoad **/ TEST_F(EnergyPlusFixture,ForwardTranslatorGeneratorMicroTurbine_ELCD_PlantLoop) { // TODO: Temporarily output the Log in the console with the Trace (-3) level // for debug // openstudio::Logger::instance().standardOutLogger().enable(); // openstudio::Logger::instance().standardOutLogger().setLogLevel(Trace); // Create a model, a mchp, a mchpHR, a plantLoop and an electricalLoadCenter Model model; GeneratorMicroTurbine mchp = GeneratorMicroTurbine(model); GeneratorMicroTurbineHeatRecovery mchpHR = GeneratorMicroTurbineHeatRecovery(model, mchp); ASSERT_EQ(mchpHR, mchp.generatorMicroTurbineHeatRecovery().get()); PlantLoop plantLoop(model); // Add a supply branch for the mchpHR ASSERT_TRUE(plantLoop.addSupplyBranchForComponent(mchpHR)); // Create a WaterHeater:Mixed WaterHeaterMixed waterHeater(model); // Add it on the same branch as the chpHR, right after it Node mchpHROutletNode = mchpHR.outletModelObject()->cast<Node>(); ASSERT_TRUE(waterHeater.addToNode(mchpHROutletNode)); // Create a plantEquipmentOperationHeatingLoad PlantEquipmentOperationHeatingLoad operation(model); operation.setName(plantLoop.name().get() + " PlantEquipmentOperationHeatingLoad"); ASSERT_TRUE(plantLoop.setPlantEquipmentOperationHeatingLoad(operation)); ASSERT_TRUE(operation.addEquipment(mchpHR)); ASSERT_TRUE(operation.addEquipment(waterHeater)); // Create an ELCD ElectricLoadCenterDistribution elcd = ElectricLoadCenterDistribution(model); elcd.setName("Capstone C65 ELCD"); elcd.setElectricalBussType("AlternatingCurrent"); elcd.addGenerator(mchp); // Forward Translates ForwardTranslator forwardTranslator; Workspace workspace = forwardTranslator.translateModel(model); EXPECT_EQ(0u, forwardTranslator.errors().size()); ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::WaterHeater_Mixed).size()); ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::ElectricLoadCenter_Distribution).size()); // The MicroTurbine should have been forward translated since there is an ELCD WorkspaceObjectVector microTurbineObjects(workspace.getObjectsByType(IddObjectType::Generator_MicroTurbine)); EXPECT_EQ(1u, microTurbineObjects.size()); // Check that the HR nodes have been set WorkspaceObject idf_mchp(microTurbineObjects[0]); EXPECT_EQ(mchpHR.inletModelObject()->name().get(), idf_mchp.getString(Generator_MicroTurbineFields::HeatRecoveryWaterInletNodeName).get()); EXPECT_EQ(mchpHR.outletModelObject()->name().get(), idf_mchp.getString(Generator_MicroTurbineFields::HeatRecoveryWaterOutletNodeName).get()); OptionalWorkspaceObject idf_operation(workspace.getObjectByTypeAndName(IddObjectType::PlantEquipmentOperation_HeatingLoad,*(operation.name()))); ASSERT_TRUE(idf_operation); // Get the extensible ASSERT_EQ(1u, idf_operation->numExtensibleGroups()); // IdfExtensibleGroup eg = idf_operation.getExtensibleGroup(0); // idf_operation.targets[0] ASSERT_EQ(1u, idf_operation->targets().size()); WorkspaceObject plantEquipmentList(idf_operation->targets()[0]); ASSERT_EQ(2u, plantEquipmentList.extensibleGroups().size()); IdfExtensibleGroup eg(plantEquipmentList.extensibleGroups()[0]); ASSERT_EQ("Generator:MicroTurbine", eg.getString(PlantEquipmentListExtensibleFields::EquipmentObjectType).get()); // This fails EXPECT_EQ(mchp.name().get(), eg.getString(PlantEquipmentListExtensibleFields::EquipmentName).get()); IdfExtensibleGroup eg2(plantEquipmentList.extensibleGroups()[1]); ASSERT_EQ("WaterHeater:Mixed", eg2.getString(PlantEquipmentListExtensibleFields::EquipmentObjectType).get()); EXPECT_EQ(waterHeater.name().get(), eg2.getString(PlantEquipmentListExtensibleFields::EquipmentName).get()); model.save(toPath("./ForwardTranslatorGeneratorMicroTurbine_ELCD_PlantLoop.osm"), true); workspace.save(toPath("./ForwardTranslatorGeneratorMicroTurbine_ELCD_PlantLoop.idf"), true); }
void MainWindow::openFile() { // If the current model has been modified, warn the user before opening the new file QMessageBox::StandardButton proceed = QMessageBox::Ok; if (modelLoaded) if (model->wasModified()) proceed = QMessageBox::question(this, tr("Network Editor for SUMO"), tr("Model has been modified and not saved. Continue opening a new file?"), QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Cancel); if (proceed == QMessageBox::Ok) { // Get file name from File Dialog QString filePath = QFileDialog::getOpenFileName(this, tr("Open SUMO Network file"), xmlPath, tr("XML Network files (*.net.xml)")); QCoreApplication::processEvents(); // Open file if (!filePath.isEmpty()) { QFile file(filePath); if (file.open(QIODevice::ReadOnly)) { // Start counting opening time QTime t; t.start(); // Create the model, parsing XML data first statusBar()->showMessage(tr("Loading XML file...")); Model *newModel = new Model(&file, this); // If the file has valid XML data, continue loading the model if (newModel->xmlDataParsed()) { // Delete the old model and connect the new one if (modelLoaded) delete model; connect(newModel, SIGNAL(statusUpdate(QString)), statusBar(), SLOT(showMessage(QString))); // Create the item selection model so that it is passed onto the // individual graphic elements as they are created treeSelections = new QItemSelectionModel(newModel); newModel->setSelectionModel(treeSelections); // Interpret XML tree and create the traffic network elements newModel->loadModel(); // Connect model with tree view tView->setModel(newModel); tView->setSelectionModel(treeSelections); tView->resizeColumnToContents(0); tView->resizeColumnToContents(1); // Connect model with network view nView->setScene(newModel->netScene); nView->setSelectionModel(treeSelections); nView->zoomExtents(); nView->setRenderHint(QPainter::Antialiasing, true); // Connect model with controls and properties view controls->reset(); controls->model = newModel; pView->model = newModel; eView->model = newModel; controlWidget->show(); propsWidget->show(); editWidget->show(); // Replace old model by new model model = newModel; modelLoaded = true; xmlPath = filePath; // Update window title QFileInfo fileInfo(file.fileName()); QString filename(fileInfo.fileName()); setWindowTitle(filename + tr(" - Network Editor for SUMO")); // Connect signals and slots between all views connect(tView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(showItem(QModelIndex))); connect(nView, SIGNAL(updateStatusBar(QString)), statusBar(), SLOT(showMessage(QString))); connect(treeSelections, SIGNAL(selectionChanged(QItemSelection, QItemSelection)), model, SLOT(selectionChanged(QItemSelection, QItemSelection))); connect(treeSelections, SIGNAL(selectionChanged(QItemSelection, QItemSelection)), pView, SLOT(selectionChanged(QItemSelection, QItemSelection))); connect(treeSelections, SIGNAL(selectionChanged(QItemSelection, QItemSelection)), eView, SLOT(selectionChanged(QItemSelection, QItemSelection))); connect(treeSelections, SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this, SLOT(scrollTo(QItemSelection, QItemSelection))); connect(model, SIGNAL(attrUpdate(QItemSelection, QItemSelection)), pView, SLOT(selectionChanged(QItemSelection, QItemSelection))); connect(model, SIGNAL(attrUpdate(QItemSelection, QItemSelection)), eView, SLOT(selectionChanged(QItemSelection, QItemSelection))); statusBar()->showMessage(tr("Ready. Model loaded in %1ms.").arg(t.elapsed())); } else { // The XML data in the file was not valid, so do not load the model delete newModel; QMessageBox::warning(this, tr("Network Editor for SUMO"), tr("Error parsing XML data.")); } // Close file file.close(); } } } }
void calcularCapsaMinimaContenidora() { first = false; const int &tam = m.vertices().size(); const Vertex *v; const Face &f = m.faces()[0]; v = &m.vertices()[f.v[0]]; xmax = xmin = (*v); ymax = ymin = *(v+1); zmax = zmin = *(v+2); for (int i = 0; i < tam; i+=3) { if (m.vertices()[i] > xmax) xmax = m.vertices()[i]; if (m.vertices()[i+1] > ymax) ymax = m.vertices()[i+1]; if (m.vertices()[i+2] > zmax) zmax = m.vertices()[i+2]; if (m.vertices()[i] < xmin) xmin = m.vertices()[i]; if (m.vertices()[i+1] < ymin) ymin = m.vertices()[i+1]; if (m.vertices()[i+2] < zmin) zmin = m.vertices()[i+2]; } centrox = (xmax + xmin)/2.; centroy = (ymax + ymin)/2.; centroz = (zmax + zmin)/2.; tamx = xmax - xmin; //tamx = ancho tamy = ymax - ymin; //tamy = alto tamz = zmax - zmin; //tamz = profundo diametro = sqrt((tamx*tamx) + (tamy*tamy) + (tamz*tamz)); if (tamx >= tamy and tamx >= tamz) escalado = tamanyQueVolem/tamx; else if (tamy >= tamx and tamy >= tamz) escalado = tamanyQueVolem/tamy; else if (tamz >= tamx and tamz >= tamy) escalado = tamanyQueVolem/tamz; subirBase = tamanyQueVolem/2.; ancho_escalado = tamx*escalado; alto_escalado = tamy*escalado; profundo_escalado = tamz*escalado; }
TEST_F(AnalysisDriverFixture,RuntimeBehavior_StopCustomAnalysis) { // Tests for stopping time < 20s. // RETRIEVE PROBLEM Problem problem = retrieveProblem("UserScriptContinuous",true,false); // DEFINE SEED Model model = model::exampleModel(); openstudio::path p = toPath("./example.osm"); model.save(p,true); FileReference seedModel(p); // CREATE ANALYSIS Analysis analysis("Stop Custom Analysis", problem, seedModel); // generate 100 random points boost::mt19937 mt; typedef boost::uniform_real<> dist_type; typedef boost::variate_generator<boost::mt19937&, dist_type > gen_type; InputVariableVector variables = problem.variables(); ContinuousVariable cvar = variables[0].cast<ContinuousVariable>(); gen_type generator0(mt,dist_type(cvar.minimum().get(),cvar.maximum().get())); cvar = variables[1].cast<ContinuousVariable>(); gen_type generator1(mt,dist_type(cvar.minimum().get(),cvar.maximum().get())); cvar = variables[2].cast<ContinuousVariable>(); gen_type generator2(mt,dist_type(cvar.minimum().get(),cvar.maximum().get())); for (int i = 0, n = 100; i < n; ++i) { std::vector<QVariant> values; double value = generator0(); values.push_back(value); value = generator1(); values.push_back(value); value = generator2(); values.push_back(value); OptionalDataPoint dataPoint = problem.createDataPoint(values); ASSERT_TRUE(dataPoint); ASSERT_TRUE(analysis.addDataPoint(*dataPoint)); } // RUN ANALYSIS ProjectDatabase database = getCleanDatabase("StopCustomAnalysis"); AnalysisDriver analysisDriver(database); AnalysisRunOptions runOptions = standardRunOptions(analysisDriver.database().path().parent_path()); runOptions.setQueueSize(2); StopWatcher watcher(analysisDriver); watcher.watch(analysis.uuid()); CurrentAnalysis currentAnalysis = analysisDriver.run(analysis,runOptions); EXPECT_EQ(2,currentAnalysis.numQueuedJobs()); EXPECT_EQ(0,currentAnalysis.numQueuedDakotaJobs()); EXPECT_EQ(100,currentAnalysis.totalNumJobsInOSIteration()); EXPECT_EQ(0,currentAnalysis.numCompletedJobsInOSIteration()); analysisDriver.waitForFinished(); EXPECT_FALSE(analysisDriver.isRunning()); EXPECT_GE(watcher.nComplete(),watcher.stopNum()); EXPECT_LE(watcher.stoppingTime(),openstudio::Time(0,0,0,20)); // check conditions afterward RunManager runManager = analysisDriver.database().runManager(); EXPECT_FALSE(runManager.workPending()); BOOST_FOREACH(const Job& job,runManager.getJobs()) { EXPECT_FALSE(job.running()); EXPECT_FALSE(job.treeRunning()); } EXPECT_TRUE(currentAnalysis.numCompletedJobsInOSIteration() > 0); EXPECT_TRUE(currentAnalysis.analysis().dataPointsToQueue().size() > 0u); EXPECT_TRUE(currentAnalysis.analysis().dataPointsToQueue().size() < 100u); EXPECT_EQ(0u,analysisDriver.currentAnalyses().size()); }
int main(int argc, char **argv) { int width,height; Camera cam; int mousedx=0; int mousedy=0; int fps=0; int nrOfObjects=0; int nrOfLights=0; float tdropoff=0.0f; float topacity=0.0f; float tradius=0.0f; int nrOfPaths=0; int nrOfParticleSystems=0; float gr=0.0f; float gg=0.0f; float gb=0.0f; sf::Clock clock; //window options width=1280; height=720; sf::WindowSettings settings; settings.DepthBits = 24; settings.StencilBits = 8; settings.AntialiasingLevel = 1; sf::Window app; app.Create(sf::VideoMode(width, height, 32), "Saints Edit", sf::Style::Close|sf::Style::Resize, settings); app.UseVerticalSync(true); GLenum err = glewInit(); if (GLEW_OK != err) { cout<<"ERROR starting GLEW: "<< glewGetErrorString(err); } //Start renderer after glewinit,GLSPprog needs it (could add init method for global renderer) Renderer rend; GUI gui; gui.init(); gui.drawSplashScreen(); app.Display(); //sets up the terrain Terrain terrain(0); PathHandler ph; LightHandler lh; ParticleHandler particleHandler; particleHandler.init(); lh.init(); ph.init(); terrain.setRadius(gui.getSliderRadius()); terrain.setOpacity(gui.getSliderOpacity()); gui.setSurfaceTexHandles(terrain.getSurfaceTexHandles()); //the gui needs the textures for browsing gui.setTerrainInfo(terrain.getTerrInfo()); rend.updateProjMatrix(width,height); rend.updateViewMatrix(cam.getViewMatrix()); terrain.updateProjMatrix(width,height); terrain.updateViewMatrix(cam.getViewMatrix()); ph.updateProjectionMatrix(width,height); ph.updateViewMatrix(cam.getViewMatrix()); glViewport(0,0,width,height); MeshHandler mh("./models/"); for(int i=0; i<mh.getNrOfMeshes(); i++) { Model tmp; tmp.setMesh(mh.getMeshInfo(i)); tmp.setBoundingBox(mh.getBoundingBox(i)); tmp.setMeshName(mh.getMeshName(i)); tmp.setType(mh.getMeshType(i)); gui.addDisplayModel(tmp); } sf::Event event; Model m; TwInit(TW_OPENGL_CORE,NULL); TwWindowSize(width,height); TwBar *myBar; myBar = TwNewBar("info"); TwDefine(" info position='25 40' size='240 320' help='Information about the map etc.' refresh=0.1 "); TwAddButton(myBar, "gi", NULL, NULL, " label='General info' "); TwAddVarRO(myBar,"fps ", TW_TYPE_INT32, &fps,NULL); TwAddVarRO(myBar,"# Models ", TW_TYPE_INT32, &nrOfObjects,NULL); TwAddVarRO(myBar,"# Lights ", TW_TYPE_INT32, &nrOfLights,NULL); TwAddVarRO(myBar,"# Particlesystems ", TW_TYPE_INT32, &nrOfParticleSystems,NULL); TwAddVarRO(myBar,"# Paths ", TW_TYPE_INT32, &nrOfPaths,NULL); TwAddSeparator(myBar, "sep1", NULL); TwAddButton(myBar, "di", NULL, NULL, " label='Brush info' "); TwAddVarRO(myBar,"Radius", TW_TYPE_FLOAT, &tradius,NULL); TwAddVarRO(myBar,"Dropoff", TW_TYPE_FLOAT, &tdropoff,NULL); TwAddVarRO(myBar,"Opacity", TW_TYPE_FLOAT, &topacity,NULL); TwAddSeparator(myBar, "sep2", NULL); TwAddButton(myBar, "ci", NULL, NULL, " label='Color selected' "); TwAddVarRO(myBar,"Red", TW_TYPE_FLOAT, &gr,NULL); TwAddVarRO(myBar,"Green", TW_TYPE_FLOAT, &gg,NULL); TwAddVarRO(myBar,"Blue", TW_TYPE_FLOAT, &gb,NULL); while (app.IsOpened()) { float normalisedx = 0; float normalisedy = 0; nrOfObjects=rend.getNrOfModels(); nrOfLights=lh.getNrOfLights(); tradius=gui.getSliderRadius(); tdropoff=gui.getSliderDropoff(); topacity=gui.getSliderOpacity(); nrOfParticleSystems=particleHandler.getNrOfParticleSystems(); nrOfPaths=ph.getNrOfPaths(); gr=gui.getNormalizedColor().x; gg=gui.getNormalizedColor().y; gb=gui.getNormalizedColor().z; getNormalizedXY(app.GetInput().GetMouseX(), app.GetInput().GetMouseY(),width,height,normalisedx, normalisedy); //events int handled; while(app.GetEvent(event)) { handled = TwEventSFML(&event, 1,6); if(!handled) { if(event.Type==sf::Event::Closed) { app.Close(); } if((event.Type == sf::Event::KeyPressed) && (event.Key.Code == sf::Key::Escape)) { app.Close(); } if(event.Type==sf::Event::MouseMoved) { if(gui.getState()==GUIstate::PAINT) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); terrain.setWorldXY(cam.getPos(),ray); } } if(event.Type == sf::Event::Resized) { height = app.GetHeight(); width = app.GetWidth(); glViewport(0,0,width,height); rend.updateProjMatrix(width,height); terrain.updateProjMatrix(width,height); ph.updateProjectionMatrix(width,height); } if(event.Type == sf::Event::MouseWheelMoved) { if(event.MouseWheel.Delta>0) cam.zoomIn(event.MouseWheel.Delta*2); else cam.zoomOut(-event.MouseWheel.Delta*2); rend.updateViewMatrix(cam.getViewMatrix()); terrain.updateViewMatrix(cam.getViewMatrix()); ph.updateViewMatrix(cam.getViewMatrix()); } if(event.Type == sf::Event::MouseButtonPressed) { if(event.MouseButton.Button==sf::Mouse::Right) { gui.showMenu(true); gui.setRightClickXY(normalisedx,normalisedy); particleHandler.unselectAllParticleModels(); } } if(event.Type == sf::Event::MouseButtonPressed) { if(event.MouseButton.Button==sf::Mouse::Left) { gui.setLeftClick(normalisedx,normalisedy); terrain.setActiveTex(gui.getActiveTex()); if(gui.checkDialogAnswer()=="GRID") { terrain.showHideGridMap(); gui.resetDialogAns(); } if(!gui.isSaveMapDialogUp()&&!gui.isLoadMapDialogUp()&&!gui.isNewMapDialogUp()) { if(gui.getState()==GUIstate::PARTICLE) { if(gui.isInDrawWindow(normalisedx,normalisedy)) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); float x=-1; float z=1; terrain.rayIntersectTerrain(cam.getPos(), ray, x, z); if(gui.isPlacingParticleSystems()) { if(x>0) { particleHandler.unselectAllParticleModels(); Particle p; p=gui.getActiveParticleModel(); p.setPos(vec3(x,gui.getActiveParticleModel().getPos().y,-z)); particleHandler.addParticleModel(p); gui.setActiveParticleModel(particleHandler.getSelectedParticle()); } } else { particleHandler.selectParticles(normalisedx,normalisedy,cam.getPos(),rend.getProjMatrix(),cam.getViewMatrix()); gui.setActiveParticleModel(particleHandler.getSelectedParticle()); } } } if(gui.getState()==GUIstate::ROAD) { if(gui.checkDialogAnswer()=="RS") { terrain.removeSelectedSurfaces(); gui.resetDialogAns(); } } if(gui.getState()==GUIstate::NONE) { if(gui.checkDialogAnswer()=="DEL") { vector<Model> rm = rend.removeSelectedModels(); lh.removeLightsBoundToModels(rm); vector<Model> tm =rend.getModels(); terrain.recalcGridAroundModel(rm,tm); terrain.removeSelectedSurfaces(); gui.resetDialogAns(); } } if(gui.getState()==GUIstate::PARTICLE) { if(gui.checkDialogAnswer()=="DEL") { particleHandler.removeSelectedParticles(); gui.resetDialogAns(); } } if(gui.getState()==GUIstate::PATH) { if(gui.checkDialogAnswer()=="DEL") { ph.removeSelectedPaths(); gui.resetDialogAns(); } if(gui.checkDialogAnswer()=="CRP") { ph.addPath(); gui.resetDialogAns(); } if(gui.isInDrawWindow(normalisedx,normalisedy)) { if(gui.isSelectingRoad()) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); float x=-1; float z=1; terrain.rayIntersectTerrain(cam.getPos(), ray, x, z); if(x>0) { ph.addFlagToCurrentPath(vec3(x,0,-z)); } } else { ph.selectPaths(normalisedx,normalisedy,cam.getPos()); } } } if(gui.getState()==GUIstate::MODEL||gui.getState()==GUIstate::NONE) { if(gui.getState()==GUIstate::MODEL) { if(gui.isInDrawWindow(normalisedx,normalisedy)) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); float x=-1; float z=1; terrain.rayIntersectTerrain(cam.getPos(), ray, x, z); if(x>0) { if(m.getType()=="light") { m.bindId(bindCounter); vec3 lpos = m.getPos(); lpos.y+=1; Light tmpLight; tmpLight.setColor(gui.getNormalizedColor()); tmpLight.setPos(lpos); tmpLight.setRadius(gui.getSliderLightRadius()); tmpLight.bindId(bindCounter); tmpLight.setContrast(gui.getContrast()); tmpLight.setLightType(LightType::POINTLIGHTSHADOW); lh.addLight(tmpLight); bindCounter++; } rend.addModel(m); terrain.setWorldXY(cam.getPos(),ray); terrain.makeGridUnderModel(m); } } } if(gui.getState()==GUIstate::NONE) { if(gui.isInDrawWindow(normalisedx,normalisedy)) { rend.selectModel(normalisedx,normalisedy,cam.getPos()); } } } if(gui.getState()==GUIstate::ROAD) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); terrain.setWorldXY(cam.getPos(),ray); terrain.selectTexSurfaces(0.5,cam.getPos(),ray); } if(gui.getState()==GUIstate::LIGHT) { if(gui.isInDrawWindow(normalisedx,normalisedy)) { if(gui.isPlacingLightMode()) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); float x=-1; float z=1; terrain.rayIntersectTerrain(cam.getPos(), ray, x, z); if(x>0) { Light l = gui.getActiveLight(); lh.deselectAllLights(); l.setPos(vec3(x,l.getPos().y,-z)); lh.addLight(l); } } else { int lightPos=lh.selectLight(normalisedx,normalisedy,cam.getPos(),rend.getProjMatrix(),cam.getViewMatrix()); if(lightPos>=0) { Light tmpl = lh.getSelectedLight(); gui.setSliderLightRadius(tmpl.getRadius()); gui.setNormalizedColor(tmpl.getColor(),tmpl.getContrast()); gui.setActiveLightModel(tmpl); } } } if(gui.checkDialogAnswer()=="DEL") { lh.removeSelectedLights(); } } } if(gui.isSaveMapDialogUp()) { if(gui.checkDialogAnswer()=="svOK") { save(gui.getInputText(),terrain,rend,ph,lh,particleHandler); gui.hideSaveMapDialog(); } if(gui.checkDialogAnswer()=="svC") { gui.hideSaveMapDialog(); } } if(gui.isNewMapDialogUp()) { if(gui.checkDialogAnswer()=="nmCS") { terrain.createNewMap(0); rend.clear(); ph.clear(); lh.clear(); particleHandler.clear(); gui.hideNewMapDialog(); } if(gui.checkDialogAnswer()=="nmCM") { terrain.createNewMap(1); rend.clear(); ph.clear(); lh.clear(); particleHandler.clear(); gui.hideNewMapDialog(); } if(gui.checkDialogAnswer()=="nmCL") { terrain.createNewMap(2); rend.clear(); ph.clear(); lh.clear(); particleHandler.clear(); gui.hideNewMapDialog(); } if(gui.checkDialogAnswer()=="nmOK") { terrain.createNewMap(0); rend.clear(); ph.clear(); lh.clear(); particleHandler.clear(); gui.hideNewMapDialog(); } if(gui.checkDialogAnswer()=="nmC") { gui.hideNewMapDialog(); } } if(gui.isLoadMapDialogUp()) { if(gui.checkDialogAnswer()=="lmOK") { load(gui.getInputText(),terrain,rend,ph,lh,particleHandler,mh); gui.hideLoadMapDialog(); } if(gui.checkDialogAnswer()=="lmC") { gui.hideLoadMapDialog(); } } } } if(event.Type == sf::Event::MouseButtonReleased) { if(event.MouseButton.Button==sf::Mouse::Right) { gui.showMenu(false); rend.unselectAllModels(); } } //if the gui excpects text input if(gui.isInTextMode()) { if(event.Type == sf::Event::KeyPressed) { if(int(event.Key.Code)>=97&&event.Key.Code<=122) gui.addChar(char(event.Key.Code)); } if((event.Type == sf::Event::KeyPressed) && (event.Key.Code == sf::Key::Back)) { gui.removeChar(); } } } } //realtime input if(app.GetInput().IsMouseButtonDown(sf::Mouse::Left)) { if(!handled) { if(!gui.isSaveMapDialogUp()&&!gui.isLoadMapDialogUp()&&!gui.isNewMapDialogUp()) { if(gui.isInDrawWindow(normalisedx,normalisedy)) { if(gui.getState()==GUIstate::PAINT) { terrain.setTerState(TerrState::PAINT); terrain.paint(cam.getPos(),inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos())); } if(gui.getState()==GUIstate::ROAD) { terrain.setTerState(TerrState::DRAWSURFACE); vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); terrain.addSurface(cam.getPos(),ray, gui.getActiveSurfaceTexHandle()); } } else { gui.moveSliders(normalisedx,normalisedy); if(gui.getState()==GUIstate::PAINT) { terrain.setRadius(gui.getSliderRadius()); terrain.setOpacity(gui.getSliderOpacity()); terrain.setDropoff(gui.getSliderDropoff()); } if(gui.getState()==GUIstate::ROAD) { terrain.setRoadSpacing(gui.getRoadSliderSpacing()); terrain.setRoadScale(gui.getRoadSliderScale()); } if(gui.getState()==GUIstate::PARTICLE) { particleHandler.assignParticleNewParticle(gui.getActiveParticleModel()); } if(gui.getState()==GUIstate::LIGHT) lh.assignLightAnotherLight(gui.getActiveLight()); } } } } if(app.GetInput().IsMouseButtonDown(sf::Mouse::Right)) { gui.setMouseXY(normalisedx,normalisedy); terrain.deselectAllSurfaceTex(); lh.deselectAllLights(); } //if the user isnt in text mode, it should be able to move if(!gui.isInTextMode()) { if(app.GetInput().IsKeyDown(sf::Key::Delete)) { if(gui.getState()==GUIstate::MODEL||gui.getState()==GUIstate::NONE) { vector<Model> rm = rend.removeSelectedModels(); lh.removeLightsBoundToModels(rm); vector<Model> tm =rend.getModels(); terrain.recalcGridAroundModel(rm,tm); } if(gui.getState()==GUIstate::PATH) { ph.removeSelectedPaths(); } if(gui.getState()==GUIstate::PARTICLE) { particleHandler.removeSelectedParticles(); } if(gui.getState()==GUIstate::ROAD) { terrain.removeSelectedSurfaces(); } if(gui.getState()==GUIstate::LIGHT) { lh.removeSelectedLights(); } } if(gui.getState()==GUIstate::PAINT) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); terrain.setWorldXY(cam.getPos(),ray); } if(app.GetInput().IsKeyDown(sf::Key::W)) { cam.moveForeward(0.1); } if(app.GetInput().IsKeyDown(sf::Key::S)) { cam.moveBackward(0.1); } if(app.GetInput().IsKeyDown(sf::Key::A)) { cam.strafeLeft(0.1); } if(app.GetInput().IsKeyDown(sf::Key::D)) { cam.strafeRight(0.1); } rend.updateViewMatrix(cam.getViewMatrix()); terrain.updateViewMatrix(cam.getViewMatrix()); ph.updateViewMatrix(cam.getViewMatrix()); if(gui.getState()==GUIstate::MODEL) { if(app.GetInput().IsKeyDown(sf::Key::Q)) gui.rotateActiveModelLeft(1.0f); if(app.GetInput().IsKeyDown(sf::Key::E)) gui.rotateActiveModelRight(1.0f); if(app.GetInput().IsKeyDown(sf::Key::R)) gui.raiseActiveModel(0.01); if(app.GetInput().IsKeyDown(sf::Key::F)) gui.raiseActiveModel(-0.01); } } if(app.GetInput().IsMouseButtonDown(sf::Mouse::Middle)) { cam.rotateLeft(mousedx-app.GetInput().GetMouseX()); cam.rotateUp(mousedy-app.GetInput().GetMouseY()); rend.updateViewMatrix(cam.getViewMatrix()); terrain.updateViewMatrix(cam.getViewMatrix()); ph.updateViewMatrix(cam.getViewMatrix()); } if(app.GetInput().IsMouseButtonDown(sf::Mouse::Right)) { gui.showMenu(true); if(gui.getState()==GUIstate::PAINT) { terrain.showCircle(); } else terrain.hideCircle(); } //saves the position of the mouse, used for rotation mousedx=app.GetInput().GetMouseX(); mousedy=app.GetInput().GetMouseY(); glClearColor(0.75f, 0.87f, 0.85f, 0.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); terrain.draw(); rend.draw(); if(gui.getState()==GUIstate::PATH) { ph.drawPaths(); if(gui.isSelectingRoad()) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); float x=-1; float z=1; terrain.rayIntersectTerrain(cam.getPos(), ray, x, z); if(x>0) ph.drawFlag(vec3(x,0,-z)); } } if(gui.getState()==GUIstate::ROAD) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); terrain.drawSurface(cam.getPos(),ray, gui.getActiveSurfaceTexHandle(),app.GetInput().IsMouseButtonDown(sf::Mouse::Left)); } if(gui.getState()==GUIstate::LIGHT) { lh.drawLights(rend.getProjMatrix(),cam.getViewMatrix()); if(gui.isPlacingLightMode()) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); float x=-1; float z=1; terrain.rayIntersectTerrain(cam.getPos(), ray, x, z); if(x>0) { Light l = gui.getActiveLight(); l.setPos(vec3(x,l.getPos().y,-z)); //l.select(); lh.drawLight(rend.getProjMatrix(),cam.getViewMatrix(),l); } } } if(gui.getState()==GUIstate::MODEL &&gui.isInDrawWindow(normalisedx,normalisedy) ) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); float x=-1; float z=1; terrain.rayIntersectTerrain(cam.getPos(), ray, x, z); if(x>0) { m=gui.getActiveModel(); m.setPos(vec3(x,gui.getActiveModel().getPos().y,-z)); m.scaleXYZ(m.getScale()); m.rotateY(m.getRot().y); rend.drawModel(m); } } if(gui.getState()==GUIstate::PARTICLE) { particleHandler.drawParticleModels(rend.getProjMatrix(),cam.getViewMatrix()); if(gui.isPlacingParticleSystems()) { vec3 ray = inters.getClickRay(app.GetInput().GetMouseX(),app.GetInput().GetMouseY(),cam.getViewMatrix(),rend.getProjMatrix(),width,height,cam.getPos()); float x=-1; float z=1; terrain.rayIntersectTerrain(cam.getPos(), ray, x, z); if(x>0) { Particle p = gui.getActiveParticleModel(); p.setPos(vec3(x,gui.getActiveParticleModel().getPos().y,-z)); particleHandler.drawParticleModel(rend.getProjMatrix(),cam.getViewMatrix(),p); } } } gui.draw(); fps= 1.0f/clock.GetElapsedTime(); clock.Reset(); TwDraw(); app.Display(); } TwTerminate(); lh.free(); return EXIT_SUCCESS; }
void load(string filename, Terrain &terr, Renderer &r, PathHandler& p, LightHandler &l, ParticleHandler &part,MeshHandler &m) { ifstream stream; string fullPath = path+filename+".txt"; stream.open(fullPath.c_str()); if(stream.is_open()) { r.clear(); l.clear(); p.clear(); part.clear(); int mapsize=0; int highBind=0; string bmp1=""; string bmp2=""; int width=0; while(!stream.eof()) { char buf[1024]; char key[1024]; stream.getline(buf, 1024); sscanf(buf, "%s", key); if(strcmp(key, "bmp1:") == 0) { char file[100]; sscanf(buf, "bmp1: %s", &file); bmp1= string(file); } else if(strcmp(key, "bmp2:") == 0) { char file[100]; sscanf(buf, "bmp2: %s", &file); bmp2= string(file); if(width == 128) mapsize=1; if(width==256) mapsize=2; terr.createNewMap(mapsize); terr.loadMaps(path+bmp1,path+bmp2,path+filename+"gm.png"); } else if(strcmp(key, "width:") == 0) { sscanf(buf, "width: %d", &width); } else if(strcmp(key, "Surfaceplanes:") == 0) { string texture; int surfCounter=-1; bool done = false; while(!done) { stream.getline(buf, 1024); sscanf(buf, "%s", key); if(strcmp(key, "SF:") == 0) { char in[100]; sscanf(buf, "SF: %s", &in); texture = string(in); surfCounter++; } else if(strcmp(key, "end") == 0) { done = true; } else // Else its an actual road piece (at least we hope so because else we are screwed) { float rot,scale; float x, z; sscanf(buf, "%f %f %f %f", &rot, &x, &z,&scale); terr.addSurface(vec3(x,0,z),rot,surfCounter,scale); //m_roads.push_back(g_graphicsEngine->createRoad(texture, FLOAT3(x, 0.0f, -z), rot)); } } } else if(strcmp(key, "MODELS:") == 0) { string s; bool done = false; while(!done) { stream.getline(buf, 1024); sscanf(buf, "%s", key); if(strcmp(key, "end") == 0) { done = true; } else { char in[100]; vec3 position; vec3 rotation; float scale; int id = 0; sscanf(buf, "%s %f %f %f %f %f %f %f %d", &in, &position.x, &position.y, &position.z, &rotation.x, &rotation.y, &rotation.z, &scale,&id); Model model; string modelName = string(in); int meshIndex = m.getMeshByName(modelName); model.setMesh(m.getMeshInfo(meshIndex)); model.setBoundingBox(m.getBoundingBox(meshIndex)); model.setMeshName(m.getMeshName(meshIndex)); model.setPos(position); model.rotateX(rotation.x); model.rotateY(rotation.y); model.rotateZ(rotation.z); model.scaleXYZ(scale); model.bindId(id); r.addModel(model); if(id>bindCounter) bindCounter=id; } } } else if(strcmp(key, "LIGHTS:") == 0) { string s; bool done = false; while(!done) { stream.getline(buf, 1024); sscanf(buf, "%s", key); if(strcmp(key, "end") == 0) { done = true; } else { char in[100]; sscanf(buf, "%s", &in); if(strcmp(key, "AM") == 0) { vec3 direction; vec3 color; vec3 rot; vec3 pos; sscanf(buf, "AM %f %f %f %f %f %f %f %f %f %f %f %f", &direction.x, &direction.y, &direction.z, &color.x, &color.y, &color.z,&rot.x,&rot.y,&rot.z,&pos.x,&pos.y,&pos.z); Light tmpLight; tmpLight.setColor(color); tmpLight.setContrast(1.0f); tmpLight.setPos(pos); tmpLight.setRadius(0); tmpLight.setLightType(LightType::AMBIENT); tmpLight.rotateX(rot.x); tmpLight.rotateY(rot.y); tmpLight.rotateZ(rot.z); l.addLight(tmpLight); } else if(strcmp(key, "PLS") == 0) { vec3 position; vec3 rotation; vec3 color; float radius; int id=0; sscanf(buf, "PLS %f %f %f %f %f %f %f %f %f %f %d", &position.x, &position.y, &position.z, &rotation.x, &rotation.y, &rotation.z, &color.x, &color.y, &color.z, &radius,&id); Light tmpLight; tmpLight.setColor(color); tmpLight.setContrast(1.0f); tmpLight.setPos(position); tmpLight.setRadius(radius); tmpLight.setLightType(LightType::POINTLIGHTSHADOW); tmpLight.rotateX(rotation.x); tmpLight.rotateY(rotation.y); tmpLight.rotateZ(rotation.z); tmpLight.bindId(id); l.addLight(tmpLight); } else if(strcmp(key, "PL") == 0) { vec3 position; vec3 rotation; vec3 color; float radius; int id=0; sscanf(buf, "PL %f %f %f %f %f %f %f %f %f %f %f", &position.x, &position.y, &position.z, &rotation.y, &rotation.x, &rotation.z, &color.x, &color.y, &color.z, &radius,&id); Light tmpLight; tmpLight.setColor(color); tmpLight.setContrast(1.0f); tmpLight.setPos(position); tmpLight.setRadius(radius); tmpLight.setLightType(LightType::POINTLIGHT); tmpLight.rotateX(rotation.x); tmpLight.rotateY(rotation.y); tmpLight.rotateZ(rotation.z); tmpLight.bindId(id); l.addLight(tmpLight); } else if(strcmp(key, "SL") == 0) { vec3 position; vec3 direction; vec3 color; vec3 rot; sscanf(buf, "SL %f %f %f %f %f %f %f %f %f %f %f %f", &position.x, &position.y, &position.z, &direction.x, &direction.y, &direction.z, &color.x, &color.y, &color.z,&rot.x, &rot.y, &rot.z); Light tmpLight; tmpLight.setColor(color); tmpLight.setContrast(1.0f); tmpLight.setPos(position); tmpLight.setRadius(0); tmpLight.setLightType(LightType::SPOTLIGHT); tmpLight.rotateX(rot.x); tmpLight.rotateY(rot.y); tmpLight.rotateZ(rot.z); l.addLight(tmpLight); } } } } else if(strcmp(key, "path") == 0) { p.addPath(); stream.getline(buf, 1024); sscanf(buf, "%s", key); int nrOfPoints = 0; vec3 points[100]; while(strcmp(key, "end") != 0) { float notInvertZ; points[nrOfPoints]=vec3(0.0f); sscanf(buf, "%f %f", &points[nrOfPoints].x, &points[nrOfPoints].z); nrOfPoints++; stream.getline(buf, 1024); sscanf(buf, "%s", key); } for(int i = 0; i < nrOfPoints; i++) { p.addFlagToCurrentPath(points[i]); } } else if(strcmp(key, "PARTICLESYSTEMS:") == 0) { string s; bool done = false; while(!done) { stream.getline(buf, 1024); sscanf(buf, "%s", key); if(strcmp(key, "end") == 0) { done = true; } else { vec3 position; vec3 rotation; vec3 color; sscanf(buf, "%s %f %f %f %f %f %f %f %f %f", &key, &position.x, &position.y, &position.z, &rotation.x, &rotation.y, &rotation.z, &color.x, &color.y, &color.z); Particle particle; particle.setPos(position); particle.rotateX(rotation.x); particle.rotateY(rotation.y); particle.rotateZ(rotation.z); particle.setColor(color); string particleType=key; if(particleType=="GLOWRING") particle.setParticleType(ParticleType::GLOWRING); if(particleType=="FIRE") particle.setParticleType(ParticleType::FIRE); if(particleType=="EMIT") particle.setParticleType(ParticleType::EMIT); if(particleType=="FLOW") particle.setParticleType(ParticleType::FLOW); if(particleType=="SMOKE") particle.setParticleType(ParticleType::SMOKE); part.addParticleModel(particle); //Create particle system int lol = 0; } } } sscanf("bugfix", "%s", key); } bindCounter++; stream.close(); } }
/** * Run a simulation of block sliding with contact on by two muscles sliding with contact */ int main() { try { // Create a new OpenSim model Model osimModel; osimModel.setName("osimModel"); double Pi = SimTK::Pi; // Get the ground body OpenSim::Body& ground = osimModel.getGroundBody(); ground.addDisplayGeometry("checkered_floor.vtp"); // create linkage body double linkageMass = 0.001, linkageLength = 0.5, linkageDiameter = 0.06; Vec3 linkageDimensions(linkageDiameter, linkageLength, linkageDiameter); Vec3 linkageMassCenter(0,linkageLength/2,0); Inertia linkageInertia = Inertia::cylinderAlongY(linkageDiameter/2.0, linkageLength/2.0); OpenSim::Body* linkage1 = new OpenSim::Body("linkage1", linkageMass, linkageMassCenter, linkageMass*linkageInertia); // Graphical representation linkage1->addDisplayGeometry("cylinder.vtp"); //This cylinder.vtp geometry is 1 meter tall, 1 meter diameter. Scale and shift it to look pretty GeometrySet& geometry = linkage1->updDisplayer()->updGeometrySet(); DisplayGeometry& thinCylinder = geometry[0]; thinCylinder.setScaleFactors(linkageDimensions); thinCylinder.setTransform(Transform(Vec3(0.0,linkageLength/2.0,0.0))); linkage1->addDisplayGeometry("sphere.vtp"); //This sphere.vtp is 1 meter in diameter. Scale it. geometry[1].setScaleFactors(Vec3(0.1)); // Creat a second linkage body OpenSim::Body* linkage2 = new OpenSim::Body(*linkage1); linkage2->setName("linkage2"); // Creat a block to be the pelvis double blockMass = 20.0, blockSideLength = 0.2; Vec3 blockMassCenter(0); Inertia blockInertia = blockMass*Inertia::brick(blockSideLength, blockSideLength, blockSideLength); OpenSim::Body *block = new OpenSim::Body("block", blockMass, blockMassCenter, blockInertia); block->addDisplayGeometry("block.vtp"); //This block.vtp is 0.1x0.1x0.1 meters. scale its appearance block->updDisplayer()->updGeometrySet()[0].setScaleFactors(Vec3(2.0)); // Create 1 degree-of-freedom pin joints between the bodies to creat a kinematic chain from ground through the block Vec3 orientationInGround(0), locationInGround(0), locationInParent(0.0, linkageLength, 0.0), orientationInChild(0), locationInChild(0); PinJoint *ankle = new PinJoint("ankle", ground, locationInGround, orientationInGround, *linkage1, locationInChild, orientationInChild); PinJoint *knee = new PinJoint("knee", *linkage1, locationInParent, orientationInChild, *linkage2, locationInChild, orientationInChild); PinJoint *hip = new PinJoint("hip", *linkage2, locationInParent, orientationInChild, *block, locationInChild, orientationInChild); double range[2] = {-SimTK::Pi*2, SimTK::Pi*2}; CoordinateSet& ankleCoordinateSet = ankle->upd_CoordinateSet(); ankleCoordinateSet[0].setName("q1"); ankleCoordinateSet[0].setRange(range); CoordinateSet& kneeCoordinateSet = knee->upd_CoordinateSet(); kneeCoordinateSet[0].setName("q2"); kneeCoordinateSet[0].setRange(range); CoordinateSet& hipCoordinateSet = hip->upd_CoordinateSet(); hipCoordinateSet[0].setName("q3"); hipCoordinateSet[0].setRange(range); // Add the bodies to the model osimModel.addBody(linkage1); osimModel.addBody(linkage2); osimModel.addBody(block); // Define contraints on the model // Add a point on line constraint to limit the block to vertical motion Vec3 lineDirection(0,1,0), pointOnLine(0,0,0), pointOnBlock(0); PointOnLineConstraint *lineConstraint = new PointOnLineConstraint(ground, lineDirection, pointOnLine, *block, pointOnBlock); osimModel.addConstraint(lineConstraint); // Add PistonActuator between the first linkage and the block Vec3 pointOnBodies(0); PistonActuator *piston = new PistonActuator(); piston->setName("piston"); piston->setBodyA(linkage1); piston->setBodyB(block); piston->setPointA(pointOnBodies); piston->setPointB(pointOnBodies); piston->setOptimalForce(200.0); piston->setPointsAreGlobal(false); osimModel.addForce(piston); //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Added ControllableSpring between the first linkage and the second block //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ControllableSpring *spring = new ControllableSpring; spring->setName("spring"); spring->setBodyA(block); spring->setBodyB(linkage1); spring->setPointA(pointOnBodies); spring->setPointB(pointOnBodies); spring->setOptimalForce(2000.0); spring->setPointsAreGlobal(false); spring->setRestLength(0.8); osimModel.addForce(spring); // define the simulation times double t0(0.0), tf(15); // create a controller to control the piston and spring actuators // the prescribed controller sets the controls as functions of time PrescribedController *legController = new PrescribedController(); // give the legController control over all (two) model actuators legController->setActuators(osimModel.updActuators()); // specify some control nodes for spring stiffness control double t[] = {0.0, 4.0, 7.0, 10.0, 15.0}; double x[] = {1.0, 1.0, 0.25, 0.25, 5.0}; // specify the control function for each actuator legController->prescribeControlForActuator("piston", new Constant(0.1)); legController->prescribeControlForActuator("spring", new PiecewiseLinearFunction(5, t, x)); // add the controller to the model osimModel.addController(legController); // define the acceration due to gravity osimModel.setGravity(Vec3(0, -9.80665, 0)); // enable the model visualizer see the model in action, which can be // useful for debugging osimModel.setUseVisualizer(true); // Initialize system SimTK::State& si = osimModel.initSystem(); // Pin joint initial states double q1_i = -Pi/4; double q2_i = - 2*q1_i; CoordinateSet &coordinates = osimModel.updCoordinateSet(); coordinates[0].setValue(si, q1_i, true); coordinates[1].setValue(si,q2_i, true); // Setup integrator and manager SimTK::RungeKuttaMersonIntegrator integrator(osimModel.getMultibodySystem()); integrator.setAccuracy(1.0e-3); ForceReporter *forces = new ForceReporter(&osimModel); osimModel.updAnalysisSet().adoptAndAppend(forces); Manager manager(osimModel, integrator); //Examine the model osimModel.printDetailedInfo(si, std::cout); // Save the model osimModel.print("toyLeg.osim"); // Print out the initial position and velocity states si.getQ().dump("Initial q's"); si.getU().dump("Initial u's"); std::cout << "Initial time: " << si.getTime() << std::endl; // Integrate manager.setInitialTime(t0); manager.setFinalTime(tf); std::cout<<"\n\nIntegrating from " << t0 << " to " << tf << std::endl; manager.integrate(si); // Save results auto controlsTable = osimModel.getControlsTable(); STOFileAdapter::write(controlsTable, "SpringActuatedLeg_controls.sto"); auto statesTable = manager.getStatesTable(); osimModel.updSimbodyEngine().convertRadiansToDegrees(statesTable); STOFileAdapter::write(statesTable, "SpringActuatedLeg_states.sto"); auto forcesTable = forces->getForcesTable(); STOFileAdapter::write(forcesTable, "SpringActuatedLeg_forces.sto"); } catch (const std::exception& ex) { std::cout << "Exception in toyLeg_example: " << ex.what() << std::endl; return 1; } std::cout << "Exiting" << std::endl; return 0; }
void Form::btnCut_clicked() { // Setup the mask int extent[6]; this->OriginalImage->GetExtent(extent); //PrintExtent("extent", extent); this->AlphaMask->SetExtent(extent); this->AlphaMask->AllocateScalars(VTK_UNSIGNED_CHAR, 1); int clippedExtent[6]; ClipFilter->GetOutput()->GetExtent(clippedExtent); //PrintExtent("clippedExtent", clippedExtent); // Initialize the mask (everything background) for(int y = extent[2]; y <= extent[3]; y++) { for(int x = extent[0]; x <= extent[1]; x++) { unsigned char* pixel = static_cast<unsigned char*>(this->AlphaMask->GetScalarPointer(x,y,0)); pixel[0] = ImageGraphCut::ALWAYSSINK; } } // Mask the foreground for(int y = clippedExtent[2]; y <= clippedExtent[3]; y++) { for(int x = clippedExtent[0]; x <= clippedExtent[1]; x++) { unsigned char* pixel = static_cast<unsigned char*>(this->AlphaMask->GetScalarPointer(x,y,0)); pixel[0] = ImageGraphCut::SOURCE; } } vtkSmartPointer<vtkJPEGWriter> writer = vtkSmartPointer<vtkJPEGWriter>::New(); writer->SetInputData(this->AlphaMask); writer->SetFileName("InitialMask.jpg"); writer->Write(); unsigned int numberOfMixtures = 5; std::vector<Model*> foregroundModels(numberOfMixtures); for(unsigned int i = 0; i < foregroundModels.size(); i++) { Model* model = new GaussianND; model->SetDimensionality(3); // rgb model->Init(); foregroundModels[i] = model; } std::vector<Model*> backgroundModels(numberOfMixtures); for(unsigned int i = 0; i < backgroundModels.size(); i++) { Model* model = new GaussianND; model->SetDimensionality(3); // rgb model->Init(); backgroundModels[i] = model; } vtkSmartPointer<vtkExpectationMaximization> emForeground = vtkSmartPointer<vtkExpectationMaximization>::New(); emForeground->SetMinChange(2.0); emForeground->SetInitializationTechniqueToKMeans(); vtkSmartPointer<vtkExpectationMaximization> emBackground = vtkSmartPointer<vtkExpectationMaximization>::New(); emBackground->SetMinChange(2.0); emBackground->SetInitializationTechniqueToKMeans(); vtkSmartPointer<ImageGraphCut> graphCutFilter = vtkSmartPointer<ImageGraphCut>::New(); graphCutFilter->BackgroundEM = emBackground; graphCutFilter->ForegroundEM = emForeground; unsigned int totalIterations = 3; for(unsigned int i = 0; i < totalIterations; i++) { std::cout << "Grabcuts iteration " << i << std::endl; // Convert these RGB colors to XYZ points to feed to EM std::vector<vnl_vector<double> > foregroundRGBpoints = CreateRGBPoints(ImageGraphCut::SOURCE); std::vector<vnl_vector<double> > backgroundRGBpoints = CreateRGBPoints(ImageGraphCut::SINK); std::vector<vnl_vector<double> > alwaysBackgroundRGBpoints = CreateRGBPoints(ImageGraphCut::ALWAYSSINK); backgroundRGBpoints.insert(backgroundRGBpoints.end(), alwaysBackgroundRGBpoints.begin(), alwaysBackgroundRGBpoints.end()); std::cout << "There are " << foregroundRGBpoints.size() << " foreground points." << std::endl; if(foregroundRGBpoints.size() < 10) { std::cerr << "There are not enough foreground points!" << std::endl; exit(-1); } std::cout << "There are " << backgroundRGBpoints.size() << " background points." << std::endl; std::cout << "Foreground EM..." << std::endl; emForeground->SetData(foregroundRGBpoints); emForeground->SetModels(foregroundModels); emForeground->Update(); std::cout << "Background EM..." << std::endl; emBackground->SetData(backgroundRGBpoints); emBackground->SetModels(backgroundModels); emBackground->Update(); // Create image from models (this is for sanity only) CreateImageFromModels(emForeground, emBackground); std::cout << "Cutting graph..." << std::endl; graphCutFilter->SetInputData(this->OriginalImage); graphCutFilter->SetSourceSinkMask(this->AlphaMask); graphCutFilter->Update(); std::cout << "Refreshing..." << std::endl; this->AlphaMask->ShallowCopy(graphCutFilter->GetOutput()); graphCutFilter->Modified(); emForeground->Modified(); emBackground->Modified(); this->Refresh(); std::stringstream ss; ss << i << ".jpg"; writer->SetFileName(ss.str().c_str()); writer->Write(); } vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New(); lookupTable->SetNumberOfTableValues(3); lookupTable->SetRange(0.0,255.0); lookupTable->SetTableValue(0, 0.0, 0.0, 0.0, ImageGraphCut::SINK); //transparent lookupTable->SetTableValue(1, 0.0, 0.0, 0.0, ImageGraphCut::ALWAYSSINK); //transparent lookupTable->SetTableValue(2, 0.0, 1.0, 0.0, FOREGROUNDALPHA); //opaque and green lookupTable->Build(); vtkSmartPointer<vtkImageMapToColors> mapTransparency = vtkSmartPointer<vtkImageMapToColors>::New(); mapTransparency->SetLookupTable(lookupTable); mapTransparency->SetInputData(graphCutFilter->GetOutput()); mapTransparency->PassAlphaToOutputOn(); this->MaskActor->SetInputData(mapTransparency->GetOutput()); this->RightRenderer->AddActor(this->MaskActor); this->Refresh(); }
void scene::displayModel(Model activeModel, Shader shader) { activeModel.draw(shader); }
void RefractionCalibration::setModel(const Model &model) { setModel(model, FixedParams(model.size(), false)); }
void calcularCapsaMinimaContenidora2() { first2 = false; const int &tam = m.vertices().size(); const Vertex *v; const Face &f = m.faces()[0]; v = &m.vertices()[f.v[0]]; xmax = xmin = (*v); ymax = ymin = *(v+1); zmax = zmin = *(v+2); for (int i = 0; i < tam; i+=3) { if (m.vertices()[i] > xmax) xmax = m.vertices()[i]; if (m.vertices()[i+1] > ymax) ymax = m.vertices()[i+1]; if (m.vertices()[i+2] > zmax) zmax = m.vertices()[i+2]; if (m.vertices()[i] < xmin) xmin = m.vertices()[i]; if (m.vertices()[i+1] < ymin) ymin = m.vertices()[i+1]; if (m.vertices()[i+2] < zmin) zmin = m.vertices()[i+2]; } centrox2 = (xmax + xmin)/2.; centroy2 = (ymax + ymin)/2.; centroz2 = (zmax + zmin)/2.; tamx2 = xmax - xmin; //tamx = ancho tamy2 = ymax - ymin; //tamy = alto tamz2 = zmax - zmin; //tamz = profundo diametro2 = sqrt((tamx2*tamx2) + (tamy2*tamy2) + (tamz2*tamz2)); if (tamx2 >= tamy2 and tamx2 >= tamz2) escalado2 = tamanyQueVolem2/tamx2; else if (tamy2 >= tamx2 and tamy2 >= tamz2) escalado2 = tamanyQueVolem2/tamy2; else if (tamz2 >= tamx2 and tamz2 >= tamy2) escalado2 = tamanyQueVolem2/tamz2; //escalado2 = tamanyQueVolem2/dimensionMasGrande subirBase2 = tamanyQueVolem2/2.; ancho_escalado2 = tamx2*escalado2; alto_escalado2 = tamy2*escalado2; profundo_escalado2 = tamz*escalado2; }
void addModelElement(Element *elem, std::vector<Row_Information_Struct> &mRowInformation, int &rowIndex, xLightsFrame *xframe, std::vector <Element*> &elements, bool submodel) { if(!elem->GetCollapsed()) { for(int j =0; j<elem->GetEffectLayerCount();j++) { Row_Information_Struct ri; ri.element = elem; ri.displayName = elem->GetName(); ri.Collapsed = elem->GetCollapsed(); ri.Active = elem->GetActive(); ri.colorIndex = 0; ri.layerIndex = j; ri.Index = rowIndex++; ri.submodel = submodel; mRowInformation.push_back(ri); } } else { Row_Information_Struct ri; ri.element = elem; ri.Collapsed = elem->GetCollapsed(); ri.displayName = elem->GetName(); ri.Active = elem->GetActive(); ri.colorIndex = 0; ri.layerIndex = 0; ri.Index = rowIndex++; ri.submodel = submodel; mRowInformation.push_back(ri); } Model *cls = xframe->GetModel(elem->GetName()); if (cls == nullptr) { return; } elem->InitStrands(*cls); if (cls->GetDisplayAs() == "ModelGroup" && elem->ShowStrands()) { wxString models = cls->GetModelXml()->GetAttribute("models"); wxArrayString model=wxSplit(models,','); for(size_t m=0;m<model.size();m++) { for (size_t x = 0; x < elements.size(); x++) { if (elements[x]->GetName() == model[m]) { addModelElement(elements[x], mRowInformation, rowIndex, xframe, elements, true); } } } } else if (elem->ShowStrands()) { for (size_t s = 0; s < elem->getStrandLayerCount(); s++) { StrandLayer * sl = elem->GetStrandLayer(s); if (elem->getStrandLayerCount() > 1) { Row_Information_Struct ri; ri.element = elem; ri.Collapsed = !elem->ShowStrands(); ri.Active = elem->GetActive(); ri.displayName = sl->GetName(); ri.colorIndex = 0; ri.layerIndex = 0; ri.Index = rowIndex++; ri.strandIndex = s; ri.submodel = submodel; mRowInformation.push_back(ri); } if (sl->ShowNodes()) { for (int n = 0; n < sl->GetNodeLayerCount(); n++) { Row_Information_Struct ri; ri.element = elem; ri.Collapsed = sl->ShowNodes(); ri.Active = !elem->GetActive(); ri.displayName = sl->GetNodeLayer(n)->GetName(); ri.colorIndex = 0; ri.layerIndex = 0; ri.Index = rowIndex++; ri.strandIndex = s; ri.nodeIndex = n; ri.submodel = submodel; mRowInformation.push_back(ri); } } } } }
int main() { sf::ContextSettings Settings; Settings.depthBits = 24; // Request a 24 bits depth buffer Settings.stencilBits = 8; // Request a 8 bits stencil buffer Settings.antialiasingLevel = 2; // Request 2 levels of antialiasing sf::Window window(sf::VideoMode(WNDW_WIDTH, WNDW_HEIGHT, 32), APP_NAME, sf::Style::Close, Settings); window.setKeyRepeatEnabled(false); // not count key holding press if (!init()) exit(EXIT_FAILURE); if (!K.init()) KinectOn = false; M.init(); std::cout << "LOADING OK" << std::endl; sf::Clock clock; sf::Time elapsed; while (window.isOpen()) { sf::Event event; while (window.pollEvent(event)) { switch (event.type) { case sf::Event::Closed: window.close(); break; case sf::Event::KeyPressed: switch (event.key.code) { case sf::Keyboard::Num1: M.increaseRotation(1, 0.0f, 0.0f); break; case sf::Keyboard::Num2: M.increaseRotation(-1, 0.0f, 0.0f); break; case sf::Keyboard::Num3: M.increaseRotation(0.0f, 1.0f, 0.0f); break; case sf::Keyboard::Num4: M.increaseRotation(0.0f, -1.0f, 0.0f); break; case sf::Keyboard::Num5: M.increaseRotation(0.0f, 0.0f, 1.0f); break; case sf::Keyboard::Num6: M.increaseRotation(0.0f, 0.0f, -1.0f); break; case sf::Keyboard::P: K.playRecord(); break; case sf::Keyboard::R: K.record(); break; case sf::Keyboard::S: K.stopRecord(); break; case sf::Keyboard::Z: M.setShocked(); break; case sf::Keyboard::X: M.undoShocked(); break; case sf::Keyboard::Escape: window.close(); break; default: break; } break; default: break; } } elapsed = clock.getElapsedTime(); if (elapsed.asSeconds() > 1.0 / 30) { // 30 fps = 1.0/60 window.setActive(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (KinectOn) { K.update(); if (K.IsTracked()) { FLOAT* sc = K.GetScale(); FLOAT* rot = K.GetRotation(); FLOAT* trans = K.GetTranslation(); FLOAT* AU = K.GetAnimationUnits(); UINT* numAU = K.GetNumAU(); FLOAT* SU = K.GetShapeUnits(); UINT* numSU = K.GetNumSU(); M.registerResult(sc, rot, trans, AU, numAU, SU, numSU); } else M.stopAnimation(); } M.update(); K.render(); M.render(); window.display(); } } return 0; }
bool PraetoriansTerrainWater::loadPackedMedia(const char* path) { unsigned int signature; unsigned short chunkid; unsigned int chunklength; unsigned int texturescount;///use one in this version unsigned int watercount; unsigned int vertexcount; unsigned int indexcount; Tuple3f* vertices; unsigned short* indices; Tuple4ub* colors; Tuple2f* txcoords; ArchivedFile* file; WaterDatabase* wdatabase; if (!(file = FileSystem::checkOut(path))) return Logger::writeErrorLog(String("Could not load -> ") + path); wdatabase = Gateway::getWaterDatabase(); file->read(&signature, 4); file->read(&chunkid, 2); file->read(&chunklength, 4); file->read(&texturescount, 4); for (unsigned int i = 0; i < texturescount; i++) file->seek((256 * 256 * 4) + 6, SEEKD); file->read(&watercount, 4); for (unsigned int i = 0; i < watercount; i++) { file->read(&chunkid, 2); file->read(&chunklength, 4); file->seek(48, SEEKD); file->read(&vertexcount, 4); vertices = new Tuple3f[vertexcount]; colors = new Tuple4ub[vertexcount]; txcoords = new Tuple2f[vertexcount]; for (unsigned int j = 0; j < vertexcount; j++) { file->read(vertices[j], 12); Swap(vertices[j].x, vertices[j].z); file->read(colors[j], 4); Swap(colors[j].x, colors[j].z); file->read(txcoords[j], 8); } file->read(&indexcount, 4); indices = new unsigned short[indexcount]; file->read(indices, indexcount * 2); String watername = String("H2O_") + int(wdatabase->getWatersCount()); Geometry* geometry; geometry = new Geometry(watername, indexcount, vertexcount); geometry->setIndices(indices, false); geometry->setVertices(vertices, false); geometry->setColors(colors, false); geometry->setTextureElements(txcoords, 2, false); geometry->computeBounds(); Appearance* appearance = new Appearance(); appearance->setBlendAttributes(BlendAttributes(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); appearance->setTexture(0, wdatabase->getWaterTexture()); Model* model = new Model(); model->setAppearance(appearance); model->setGeometry(geometry); TransformGroup* group = new TransformGroup(); group->addChild(model); group->updateBoundsDescriptor(); wdatabase->addWaterModel(group); deleteArray(vertices); deleteArray(indices); deleteArray(colors); deleteArray(txcoords); } FileSystem::checkIn(file); return true; }
/* * Setup OpenGL * * Set up GLFW and GLEW, opens a window. */ void SetupOpenGL() { if (!glfwInit()) { std::cerr << "Failed to initialize GLFW." << std::endl; exit(1); } glfwWindowHint(GLFW_SAMPLES, 4); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); s_window = glfwCreateWindow(1024, 768, "Bullet + OpenGL", nullptr, nullptr); if (s_window == nullptr) { std::cerr << "Failed to open GLFW window." << std::endl; glfwTerminate(); exit(1); } glfwMakeContextCurrent(s_window); glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { std::cerr << "Failed to initialize GLEW." << std::endl; glfwTerminate(); exit(1); } glfwSetInputMode(s_window, GLFW_STICKY_KEYS, GL_TRUE); glfwSetCursorPos(s_window, 1024/2, 768/2); glClearColor(0.0f, 0.0f, 0.4f, 0.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); glGenVertexArrays(1, &s_vertexArrayId); glBindVertexArray(s_vertexArrayId); s_model = LoadModelFromObjFile("../res/textures/cube.obj"); glGenBuffers(1, &s_vertexBufferId); glBindBuffer(GL_ARRAY_BUFFER, s_vertexBufferId); glBufferData(GL_ARRAY_BUFFER, s_model.vertices().size() * sizeof(glm::vec3), &s_model.vertices()[0], GL_STATIC_DRAW); glGenBuffers(1, &s_uvCoordBufferId); glBindBuffer(GL_ARRAY_BUFFER, s_uvCoordBufferId); glBufferData(GL_ARRAY_BUFFER, s_model.uvCoords().size() * sizeof(glm::vec2), &s_model.uvCoords()[0], GL_STATIC_DRAW); glGenBuffers(1, &s_normalBufferId); glBindBuffer(GL_ARRAY_BUFFER, s_normalBufferId); glBufferData(GL_ARRAY_BUFFER, s_model.normals().size() * sizeof(glm::vec3), &s_model.normals()[0], GL_STATIC_DRAW); LoadShaders("../res/shaders/vertex.glsl", "../res/shaders/fragment.glsl"); s_mvpMatrixId = glGetUniformLocation(s_programId, "mvpMatrix"); s_modelMatrixId = glGetUniformLocation(s_programId, "modelMatris"); s_viewMatrixId = glGetUniformLocation(s_programId, "modelMatrix"); s_textureId = LoadDDS("../res/textures/uvmap.DDS"); s_uniformTextureId = glGetUniformLocation(s_programId, "myTextureSampler"); glUseProgram(s_programId); s_lightPositionId = glGetUniformLocation(s_programId, "lightPosition_worldspace"); s_lightColorId = glGetUniformLocation(s_programId, "lightColor"); s_lightPowerId = glGetUniformLocation(s_programId, "lightPower"); }
int main() { // Load data std::string fileName = getAbsModelPath("icub_sensorised.urdf"); Model fullModel = getModel(fileName); SensorsList fullSensors = getSensors(fileName); // Store data for a given FT sensor DataFT dataFT_l_leg; dataFT_l_leg.jointName = "l_leg_ft_sensor"; // Links dataFT_l_leg.parent_linkName = "l_hip_2"; dataFT_l_leg.child_linkName = "l_hip_3"; dataFT_l_leg.grandparent_linkName = "l_hip_1"; dataFT_l_leg.grandchild_linkName = "l_upper_leg"; // Joints dataFT_l_leg.grandparentToParent_jointName = "l_hip_roll"; dataFT_l_leg.childToGranchild_jointName = "l_hip_yaw"; // Get all the iCub joints vector<string> fullJoints = get_iCubJointsSensorised(); // Keep only one FT vector<string> removedJoints; removedJoints.push_back("r_leg_ft_sensor"); removedJoints.push_back("l_foot_ft_sensor"); removedJoints.push_back("r_foot_ft_sensor"); removedJoints.push_back("l_arm_ft_sensor"); removedJoints.push_back("r_arm_ft_sensor"); vector<string> fullJoints_1FT = removeJoints(fullJoints, removedJoints); // Setup the experiments // --------------------- // 1) The reduced model doesn't lump links which the FT is connected ExperimentFT test_defaultModel; test_defaultModel.dataFT = dataFT_l_leg; test_defaultModel.expectedFirstLinkName = dataFT_l_leg.parent_linkName; test_defaultModel.expectedSecondLinkName = dataFT_l_leg.child_linkName; // 2) The reduced model doesn't contain the firstLink ExperimentFT test_removeFirstLink; test_removeFirstLink.dataFT = dataFT_l_leg; test_removeFirstLink.removedJoints.push_back(test_removeFirstLink.dataFT.grandparentToParent_jointName); test_removeFirstLink.expectedFirstLinkName = dataFT_l_leg.grandparent_linkName; test_removeFirstLink.expectedSecondLinkName = dataFT_l_leg.child_linkName; // 3) The reduced model doesn't contain the secondLink ExperimentFT test_removeSecondLink; test_removeSecondLink.dataFT = dataFT_l_leg; test_removeSecondLink.removedJoints.push_back(test_removeSecondLink.dataFT.childToGranchild_jointName); test_removeSecondLink.expectedFirstLinkName = dataFT_l_leg.parent_linkName; test_removeSecondLink.expectedSecondLinkName = dataFT_l_leg.child_linkName; // 3) The reduced model doesn't contain both firstLink and secondLink ExperimentFT test_removeFirstAndSecondLink; test_removeFirstAndSecondLink.dataFT = dataFT_l_leg; test_removeFirstAndSecondLink.removedJoints.push_back(test_removeFirstAndSecondLink.dataFT.grandparentToParent_jointName); test_removeFirstAndSecondLink.removedJoints.push_back(test_removeFirstAndSecondLink.dataFT.childToGranchild_jointName); test_removeFirstAndSecondLink.expectedFirstLinkName = dataFT_l_leg.grandparent_linkName; test_removeFirstAndSecondLink.expectedSecondLinkName = dataFT_l_leg.child_linkName; // Group all the experiments together vector<ExperimentFT> experiments; experiments.push_back(test_defaultModel); experiments.push_back(test_removeFirstLink); experiments.push_back(test_removeSecondLink); experiments.push_back(test_removeFirstAndSecondLink); for (auto experiment : experiments) { bool ok; Model reducedModel; SensorsList reducedSensors; ok = createReducedModelAndSensors(fullModel, fullSensors, removeJoints(fullJoints_1FT, experiment.removedJoints), reducedModel, reducedSensors); ASSERT_IS_TRUE(ok); ASSERT_EQUAL_DOUBLE(reducedSensors.getNrOfSensors(SIX_AXIS_FORCE_TORQUE), 1); Sensor* s = reducedSensors.getSensor(SIX_AXIS_FORCE_TORQUE, 0); ASSERT_IS_TRUE(s != nullptr); ASSERT_IS_TRUE(s->isValid()); JointSensor* jointSens = dynamic_cast<JointSensor*>(s); ASSERT_IS_TRUE(jointSens != nullptr); unique_ptr<SixAxisForceTorqueSensor> sensorCopy; sensorCopy.reset(static_cast<SixAxisForceTorqueSensor*>(jointSens->clone())); ASSERT_IS_TRUE(sensorCopy != nullptr); printFT(*sensorCopy); cout << endl; ASSERT_EQUAL_STRING(sensorCopy->getFirstLinkName(), experiment.expectedFirstLinkName); ASSERT_EQUAL_STRING(sensorCopy->getSecondLinkName(), experiment.expectedSecondLinkName); // Test transform // -------------- // Get the transform from the fixed joint. // It uses the createReducedModel() logic. It is used as ground truth. Transform parent_H_child; auto jointFT = reducedModel.getJoint(reducedModel.getJointIndex(experiment.dataFT.jointName)); parent_H_child = jointFT->getRestTransform(jointFT->getFirstAttachedLink(), jointFT->getSecondAttachedLink()); // Get the transform from the sensor. // This is calculated by createReducedModelAndSensors() and it is the method under test. LinkIndex firstLinkIndex = sensorCopy->getFirstLinkIndex(); LinkIndex secondLinkIndex = sensorCopy->getSecondLinkIndex(); Transform firstLink_H_sensorFrame; Transform secondLink_H_sensorFrame; ok = true; ok = ok && sensorCopy->getLinkSensorTransform(firstLinkIndex, firstLink_H_sensorFrame); ok = ok && sensorCopy->getLinkSensorTransform(secondLinkIndex, secondLink_H_sensorFrame); ASSERT_IS_TRUE(ok); ASSERT_EQUAL_TRANSFORM(parent_H_child, firstLink_H_sensorFrame*secondLink_H_sensorFrame.inverse()); } return EXIT_SUCCESS; }
int main() { SetupOpenGL(); std::unique_ptr<btBroadphaseInterface> broadphase { new btDbvtBroadphase }; std::unique_ptr<btDefaultCollisionConfiguration> collisionConfiguration { new btDefaultCollisionConfiguration }; std::unique_ptr<btCollisionDispatcher> dispatcher { new btCollisionDispatcher { collisionConfiguration.get() } }; std::unique_ptr<btSequentialImpulseConstraintSolver> solver { new btSequentialImpulseConstraintSolver }; std::unique_ptr<btDiscreteDynamicsWorld> dynamicsWorld { new btDiscreteDynamicsWorld { dispatcher.get(), broadphase.get(), solver.get(), collisionConfiguration.get() } }; dynamicsWorld->setGravity(btVector3 { 0, -10, 0 }); std::unique_ptr<btCollisionShape> groundShape { new btStaticPlaneShape { btVector3 { 0, 1, 0 }, 1 } }; std::unique_ptr<btSphereShape> fallShape { new btSphereShape { 1 } }; std::unique_ptr<btDefaultMotionState> groundMotionState { new btDefaultMotionState { btTransform { btQuaternion { 0, 0, 0, 1 }, btVector3 { 0, -1, 0 } } } }; btRigidBody::btRigidBodyConstructionInfo groundRigidBodyConstructionInfo { 0, groundMotionState.get(), groundShape.get(), btVector3 { 0, 0, 0 } }; std::unique_ptr<btRigidBody> groundRigidBody { new btRigidBody { groundRigidBodyConstructionInfo } }; dynamicsWorld->addRigidBody(groundRigidBody.get()); std::unique_ptr<btDefaultMotionState> fallMotionState { new btDefaultMotionState { btTransform { btQuaternion { 0, 0, 0, 1 }, btVector3 { 0, 50, 0 } } } }; btScalar mass { 1 }; btVector3 fallInertia { 0, 0, 0 }; fallShape->calculateLocalInertia(mass, fallInertia); btRigidBody::btRigidBodyConstructionInfo fallRigidBodyConstructionInfo { mass, fallMotionState.get(), fallShape.get(), fallInertia }; std::unique_ptr<btRigidBody> fallRigidBody { new btRigidBody { fallRigidBodyConstructionInfo } }; dynamicsWorld->addRigidBody(fallRigidBody.get()); glm::mat4 projectionMatrix = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 viewMatrix; glm::mat4 modelMatrix; glm::mat4 mvp; glm::vec3 lightPosition { 3, 3, 3 }; glm::vec3 lightColor { 1, 1, 1 }; float lightPower { 50.0f }; btTransform transformation; double currentTime, lastTime = glfwGetTime(); double fps { 0.0 }; size_t nFrames { 0l }; do { dynamicsWorld->stepSimulation(1 / 60.0f, 10); fallRigidBody->getMotionState()->getWorldTransform(transformation); ProcessInputs(); modelMatrix = glm::translate(glm::mat4 { 1.0f }, glm::vec3 { transformation.getOrigin().getX(), transformation.getOrigin().getY(), transformation.getOrigin().getZ() }); viewMatrix = glm::lookAt( s_position, s_position + s_direction, s_up ); mvp = projectionMatrix * viewMatrix * modelMatrix; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glUseProgram(s_programId); glUniformMatrix4fv(s_mvpMatrixId, 1, GL_FALSE, &mvp[0][0]); glUniformMatrix4fv(s_modelMatrixId, 1, GL_FALSE, &modelMatrix[0][0]); glUniformMatrix4fv(s_viewMatrixId, 1, GL_FALSE, &viewMatrix[0][0]); glUniform3f(s_lightPositionId, lightPosition.x, lightPosition.y, lightPosition.z); glUniform3f(s_lightColorId, lightColor.x, lightColor.y, lightColor.z); glUniform1f(s_lightPowerId, lightPower); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, s_textureId); glUniform1i(s_uniformTextureId, 0); glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, s_vertexBufferId); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr); glEnableVertexAttribArray(1); glBindBuffer(GL_ARRAY_BUFFER, s_uvCoordBufferId); glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr); glEnableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, s_normalBufferId); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, nullptr); glDrawArrays(GL_TRIANGLES, 0, s_model.vertices().size()); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); currentTime = glfwGetTime(); ++nFrames; if (currentTime - lastTime > 1.0) { fps = 1000.0/nFrames; nFrames = 0; lastTime += 1.0; } ShowStatus(transformation.getOrigin().getY(), fps); glfwSwapBuffers(s_window); glfwPollEvents(); } while (glfwGetKey(s_window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwGetKey(s_window, GLFW_KEY_Q) != GLFW_PRESS && glfwWindowShouldClose(s_window) == 0); dynamicsWorld->removeRigidBody(fallRigidBody.get()); dynamicsWorld->removeRigidBody(groundRigidBody.get()); CleanupOpenGL(); return 0; }
/* * Checks that all ids on KineticLawParameters are unique. */ void UniqueVarsInRules::doCheck (const Model& m) { for (unsigned int n = 0; n < m.getNumRules(); ++n) checkId( *m.getRule(n) ); }
int main() { Model model; model.setName("bicep_curl"); #ifdef VISUALIZE model.setUseVisualizer(true); #endif // Create two links, each with a mass of 1 kg, center of mass at the body's // origin, and moments and products of inertia of zero. OpenSim::Body* humerus = new OpenSim::Body("humerus", 1, Vec3(0), Inertia(0)); OpenSim::Body* radius = new OpenSim::Body("radius", 1, Vec3(0), Inertia(0)); // Connect the bodies with pin joints. Assume each body is 1 m long. PinJoint* shoulder = new PinJoint("shoulder", // Parent body, location in parent, orientation in parent. model.getGround(), Vec3(0), Vec3(0), // Child body, location in child, orientation in child. *humerus, Vec3(0, 1, 0), Vec3(0)); PinJoint* elbow = new PinJoint("elbow", *humerus, Vec3(0), Vec3(0), *radius, Vec3(0, 1, 0), Vec3(0)); // Add a muscle that flexes the elbow. Millard2012EquilibriumMuscle* biceps = new Millard2012EquilibriumMuscle("biceps", 200, 0.6, 0.55, 0); biceps->addNewPathPoint("origin", *humerus, Vec3(0, 0.8, 0)); biceps->addNewPathPoint("insertion", *radius, Vec3(0, 0.7, 0)); // Add a controller that specifies the excitation of the muscle. PrescribedController* brain = new PrescribedController(); brain->addActuator(*biceps); // Muscle excitation is 0.3 for the first 0.5 seconds, then increases to 1. brain->prescribeControlForActuator("biceps", new StepFunction(0.5, 3, 0.3, 1)); // Add components to the model. model.addBody(humerus); model.addBody(radius); model.addJoint(shoulder); model.addJoint(elbow); model.addForce(biceps); model.addController(brain); // Add a console reporter to print the muscle fiber force and elbow angle. ConsoleReporter* reporter = new ConsoleReporter(); reporter->set_report_time_interval(1.0); reporter->addToReport(biceps->getOutput("fiber_force")); reporter->addToReport( elbow->getCoordinate(PinJoint::Coord::RotationZ).getOutput("value"), "elbow_angle"); model.addComponent(reporter); // Add display geometry. Ellipsoid bodyGeometry(0.1, 0.5, 0.1); bodyGeometry.setColor(Gray); // Attach an ellipsoid to a frame located at the center of each body. PhysicalOffsetFrame* humerusCenter = new PhysicalOffsetFrame( "humerusCenter", *humerus, Transform(Vec3(0, 0.5, 0))); humerus->addComponent(humerusCenter); humerusCenter->attachGeometry(bodyGeometry.clone()); PhysicalOffsetFrame* radiusCenter = new PhysicalOffsetFrame( "radiusCenter", *radius, Transform(Vec3(0, 0.5, 0))); radius->addComponent(radiusCenter); radiusCenter->attachGeometry(bodyGeometry.clone()); // Configure the model. State& state = model.initSystem(); // Fix the shoulder at its default angle and begin with the elbow flexed. shoulder->getCoordinate().setLocked(state, true); elbow->getCoordinate().setValue(state, 0.5 * Pi); model.equilibrateMuscles(state); // Configure the visualizer. #ifdef VISUALIZE model.updMatterSubsystem().setShowDefaultGeometry(true); Visualizer& viz = model.updVisualizer().updSimbodyVisualizer(); viz.setBackgroundType(viz.SolidColor); viz.setBackgroundColor(White); #endif // Simulate. simulate(model, state, 10.0); return 0; };
void SetOptimizationPdvsAndAdvs( Optimizer * aOptimizer, Problem * aProblem ) { // UInt modelId = 1; // Model* model = aProblem->GetModelById( 1 ); // Mesh* mesh = model->GetMesh(); // // model->BuildNodeToElementTable(); // // // Vars for creating PDVs // DesignDepObject desDepObj = NOD_PROP; // UInt propId = 11; // int propType = NP_LS; // // UInt myNumNodesInSet = model->GetNumNodes(); // // // ------------------------------------------------------------------------ // std::vector < UInt > &DesVarKeys = aOptimizer->GetMyDesVarKeys(); // // DesVarKeys.assign( myNumNodesInSet, 0 ); // // for ( UInt in = 0; in < myNumNodesInSet; ++in ) // DesVarKeys[in] = model->GetNode( in )->GetIdNum(); // // // Set the number of design variables per processor // aOptimizer->FinalizeDesVarCreation(); // // // ------------------------------------------------------------------------ // // Create PDVs // std::vector < UInt > globalNodesIds( myNumNodesInSet, 0 ); // for ( UInt in = 0; in < myNumNodesInSet; ++in ) // globalNodesIds[in] = model->GetNode( in )->GetIdNum(); // // UInt *ElemIndices = NULL, *ElemIds = NULL; // UInt numLoadElems = 0; // // // Initialize a ParseModelHelper // ParseModelHelper parseModelHelper = ParseModelHelper(); // // // Kill filter in inflow and outflow. // std::vector< UInt > noFilterNodeIds; // // numLoadElems = parseModelHelper.GetSideSetNeighborElemsInfoByID( mesh, sSSetIds[sLoadNSSetIndx], ElemIndices, ElemIds ); // for ( UInt ie = 0; ie < numLoadElems; ++ie ) { // std::vector < UInt > NodeIdsVec( FP_MAX_NODES, 0 ); // Element* elem = model->GetElement( ElemIndices[ie] ); // UInt numNodes = elem->GetNodeIds( &NodeIdsVec[0] ); // // for ( UInt in = 0; in < numNodes; ++in ) { // noFilterNodeIds.push_back( NodeIdsVec[in] ); // } // } // // FemdocAlgorithms::SortUniqueResizeStdVector( noFilterNodeIds ); // // // Read file // std::string line; // std::ifstream myfile ( "disttable" ); // // if ( myfile.is_open() ) // { // std::fprintf( stdout, "\n ... Reading PDVs file\n" ); // while ( myfile.good() ) // { // getline( myfile, line ); // // // char* lineChar = new char[line.size() + 1]; // // lineChar[line.size()] = 0; // // memcpy( lineChar, line.c_str(), line.size() ); // // const char* lineChar = line.c_str(); // // Real test1 = 0.0; // Real test2 = 0.0; // // std::sscanf( lineChar, "%lf %lf", &test1, &test2 ); // UInt glbNodeId = test1; // UInt numNeigb = test2; // // assert( numNeigb > 0 ); // // if ( std::find( &globalNodesIds[0], &globalNodesIds[0] + myNumNodesInSet, glbNodeId ) - &globalNodesIds[0] != myNumNodesInSet ) // { // Node* node = model->GetNodeById( glbNodeId ); // // std::vector < UInt > neigbIdsVec ( ( UInt ) numNeigb , 0.0 ); // std::vector < Real > neigbWgtVec ( ( UInt ) numNeigb , 0.0 ); // // if ( node ) // { // // If found in no filter IDs. // if ( std::find( &noFilterNodeIds[0], &noFilterNodeIds[0] + ( UInt ) noFilterNodeIds.size(), glbNodeId ) - &noFilterNodeIds[0] != ( UInt ) noFilterNodeIds.size() ) { // UInt numEntries[] = {1,0}; // // neigbIdsVec[0] = glbNodeId - 1; // neigbWgtVec[0] = 1.0; // // UInt paramIndex = 0; // UInt propTypeKey = node->GetIndexNum(); // PhysicalDesignVar* pdv = aOptimizer->CreatePhysDesVar( aProblem, modelId, desDepObj, propId, propType, propTypeKey, paramIndex ); // // Function* PDVEvalFunc = new FunctionScalarProduct( numEntries, &neigbWgtVec[0] ); // pdv->CreateEvaluationFunction( PDVEvalFunc, &neigbIdsVec[0] ); // } // else { // Real neighborIds = 0; // Real neighborWgt = 0; // UInt position = 28; // for ( UInt ii = 0; ii < numNeigb; ii++ ) // { // std::sscanf( lineChar + position,"%lf",&neighborIds ); // neigbIdsVec[ii] = neighborIds - 1; // position += 14; // } // for ( UInt ii = 0; ii < numNeigb; ii++ ) // { // std::sscanf( lineChar + position,"%lf",&neighborWgt ); // neigbWgtVec[ii] = neighborWgt; // position += 14; // } // // UInt numEntries[] = {numNeigb, 0}; // UInt paramIndex = 0; // UInt propTypeKey = node->GetIndexNum(); // PhysicalDesignVar* pdv = aOptimizer->CreatePhysDesVar( aProblem, modelId, desDepObj, propId, propType, propTypeKey, paramIndex ); // // Function* PDVEvalFunc = new FunctionScalarProduct( numEntries, &neigbWgtVec[0] ); // pdv->CreateEvaluationFunction( PDVEvalFunc, &neigbIdsVec[0] ); // } // } // } // } // } // else // { // std::fprintf( stdout, " Unable to open file!!!\n" ); // } // Set number of abstract design variables (radius) UInt modelId = 1; UInt numAbsDesVar = 1; UInt AbsDesVarInd[] = {0}; // ------------------------------------------------------------------------ // Set number of abstract design variables aOptimizer->SetNumDesVars(numAbsDesVar); // ------------------------------------------------------------------------ // Create PDV's DesignDepObject desDepObj = NOD_PROP; UInt propId = 11; Int propType = NP_LS; PhysicalDesignVar* pdv = NULL; // Create optimizer sweep function UInt numParameters[] = { 1, 1 }; // number of coefficients and independent variables Real ParameterVals[] = { 0.0 }; // radius and center of circle Real CntrXGlbCoords = sCenterX; Real CntrYGlbCoords = sCenterY; Real CntrZGlbCoords = sCenterZ; Model* model = aProblem->GetModelById(modelId); UInt numNodes = model->GetNumNodes(); model->BuildNodeToElementTable(); Node* node = NULL; Real NodeXGlbCoords = 0.0; Real NodeYGlbCoords = 0.0; Real NodeZGlbCoords = 0.0; for ( UInt in = 0; in < numNodes; ++in ) { node = model->GetNode(in); NodeXGlbCoords = node->GetGlobalXCoord(); NodeYGlbCoords = node->GetGlobalYCoord(); NodeZGlbCoords = node->GetGlobalZCoord(); Real distance = std::sqrt( std::pow((NodeXGlbCoords-CntrXGlbCoords),2) + std::pow((NodeYGlbCoords-CntrYGlbCoords),2) + std::pow((NodeZGlbCoords-CntrZGlbCoords),2)); ParameterVals[0] = distance; // Parameters for moving circle will be [distance, xcoords of node, ycoords of node, zcoords of node] pdv = aOptimizer->CreatePhysDesVar(aProblem,modelId,desDepObj,propId,propType,node->GetIndexNum()); Function* SweepFunc = new FunctionUserDefined(numParameters,ParameterVals,mySweepFunc,mySweepFuncDeriv); pdv->CreateEvaluationFunction(SweepFunc,AbsDesVarInd); } }
void Renderer::render( Scene* toRender ) { glClearColor(1.0f,0.8f,0.8f,1.0f); Program::checkGLErrors( "glClearColor" ); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); Program::checkGLErrors( "glClear" ); glm::mat4 mv, mvp; glm::mat3 rot, normal; ModelData data; Model model; Material mat; Program* shader; std::vector<DisplayObject> objects = toRender->getDisplayObjects(); for(int i = 0; i < objects.size(); i++) { model = objects[i].getModel(); for(int j = 0; j < model.numMeshes(); j++) { //Doesn't work ;_; //mat = *(objects[i].getMaterial( model.getMeshInfo(j).matIndex )); if(objects[i].customMatAvailable) mat = (objects[i].getMaterial(0)); else mat = model.materials[ model.getMeshInfo(j).matIndex ]; shader = mat.shader; setActiveProgram( shader ); Program::checkGLErrors( "Setting active program" ); glBindVertexArray( model.getVAO( j ) ); Program::checkGLErrors("Binding vertex array"); glBindTexture( GL_TEXTURE_2D, mat.texDiffuse ); Program::checkGLErrors( "Binding texture" ); //Update uniforms just loads the constant uniforms, e.g. Ld and stuff. updateUniforms( objects[i] ); glDrawElements(GL_TRIANGLES, model.getMeshInfo(j).numIndices, GL_UNSIGNED_INT, NULL); if( objects[i].renderBoundingBox ) { setActiveProgram( simplePr ); glBindVertexArray( bBoxVao ); glBindTexture( GL_TEXTURE_2D, 0 ); glBindBuffer( GL_ARRAY_BUFFER, model.getMeshInfo( j ).boundingBoxBuffer ); //When you finally fix updateUniforms such that it isn't horrible, make sure to give a way to only send the mvp matrix in, so we can delete this line glm::mat4 mv = projection * (camera * objects[i].getTransform()); glUniformMatrix4fv(activeProgram->getUniform("mvp"), 1, GL_FALSE, glm::value_ptr(mv) ); glVertexAttribPointer( simplePr->getAttrib("theV"),3,GL_FLOAT,0,0,0); glEnableVertexAttribArray(simplePr->getAttrib("theV")); glDrawElements(GL_LINE_STRIP,20, GL_UNSIGNED_INT, NULL); } } glBindVertexArray( 0 ); glBindTexture( GL_TEXTURE_2D, 0 ); setActiveProgram( 0 ); } glFlush(); Program::checkGLErrors("Post render"); }