//! Constructor. IAtmosphereStarSceneNode::IAtmosphereStarSceneNode(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id, video::ITexture* sun, video::ITexture* moon, const core::dimension2df& size) : scene::ISceneNode(parent, mgr, id) { #ifdef _DEBUG setDebugName("IAtmospherStarSceneNode"); #endif setSize(size); setAutomaticCulling(scene::EAC_OFF); BufferSun = new scene::SMeshBuffer(); BufferSun->Material.Lighting = false; BufferSun->Material.ZBuffer = video::ECFN_NEVER; BufferSun->Material.ZWriteEnable = false; BufferSun->Material.AntiAliasing = video::EAAM_OFF; BufferSun->Material.setTexture(0, sun); BufferSun->Material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL; BufferMoon = new scene::SMeshBuffer(); BufferMoon->Material.Lighting = false; BufferMoon->Material.ZBuffer = video::ECFN_NEVER; BufferMoon->Material.ZWriteEnable = false; BufferMoon->Material.AntiAliasing = video::EAAM_OFF; BufferMoon->Material.setTexture(0, moon); BufferMoon->Material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL; generateMesh(); }
CSkyDomeSceneNode::CSkyDomeSceneNode(video::ITexture* sky, u32 horiRes, u32 vertRes, f32 texturePercentage, f32 spherePercentage, f32 radius, ISceneNode* parent, ISceneManager* mgr, s32 id) : ISceneNode(parent, mgr, id), Buffer(0), HorizontalResolution(horiRes), VerticalResolution(vertRes), TexturePercentage(texturePercentage), SpherePercentage(spherePercentage), Radius(radius) { #ifdef _DEBUG setDebugName("CSkyDomeSceneNode"); #endif setAutomaticCulling(scene::EAC_OFF); Buffer = new CMeshBuffer<video::S3DVertex>(mgr->getVideoDriver()->getVertexDescriptor(0)); Buffer->getMaterial().Lighting = false; Buffer->getMaterial().ZBuffer = video::ECFN_DISABLED; Buffer->getMaterial().ZWriteEnable = false; Buffer->getMaterial().AntiAliasing = video::EAAM_OFF; Buffer->getMaterial().setTexture(0, sky); Buffer->getBoundingBox().MaxEdge.set(0, 0, 0); Buffer->getBoundingBox().MinEdge.set(0,0,0); // regenerate the mesh generateMesh(); }
CSkyDomeSceneNode::CSkyDomeSceneNode(video::ITexture* sky, u32 horiRes, u32 vertRes, f32 texturePercentage, f32 spherePercentage, f32 radius, ISceneNode* parent, ISceneManager* mgr, s32 id) : ISceneNode(parent, mgr, id), Buffer(0), HorizontalResolution(horiRes), VerticalResolution(vertRes), TexturePercentage(texturePercentage), SpherePercentage(spherePercentage), Radius(radius) { #ifdef _DEBUG setDebugName("CSkyDomeSceneNode"); #endif setAutomaticCulling(scene::EAC_OFF); Buffer = new SMeshBuffer(); Buffer->Material.Lighting = false; Buffer->Material.ZBuffer = video::ECFN_NEVER; Buffer->Material.ZWriteEnable = false; Buffer->Material.AntiAliasing = video::EAAM_OFF; Buffer->Material.setTexture(0, sky); Buffer->BoundingBox.MaxEdge.set(0,0,0); Buffer->BoundingBox.MinEdge.set(0,0,0); Buffer->Vertices.clear(); Buffer->Indices.clear(); // regenerate the mesh generateMesh(); }
CSkyDomeSceneNode::CSkyDomeSceneNode(video::IVirtualTexture* sky, uint32_t horiRes, uint32_t vertRes, float texturePercentage, float spherePercentage, float radius, IDummyTransformationSceneNode* parent, ISceneManager* mgr, int32_t id) : ISceneNode(parent, mgr, id), Buffer(0), HorizontalResolution(horiRes), VerticalResolution(vertRes), TexturePercentage(texturePercentage), SpherePercentage(spherePercentage), Radius(radius) { #ifdef _DEBUG setDebugName("CSkyDomeSceneNode"); #endif setAutomaticCulling(scene::EAC_OFF); Buffer = new video::IGPUMeshBuffer(); Buffer->getMaterial().ZBuffer = video::ECFN_NEVER; Buffer->getMaterial().BackfaceCulling = false; Buffer->getMaterial().ZWriteEnable = false; Buffer->getMaterial().setTexture(0, sky); BoundingBox.MaxEdge.set(0,0,0); BoundingBox.MinEdge.set(0,0,0); // regenerate the mesh generateMesh(); }
void GameInterior::onAddToScene() { Parent::onAddToScene(); // create the interior // TODO: create a resource cache for difs DIF::DIF dif; std::string path = mInteriorFile.c_str(); std::string directory = IO::getPath(path); std::ifstream file(path, std::ios::binary); if (!dif.read(file)) { IO::printf("DIF file could not be read!\n"); return; } // load interior mInterior = dif.interior[0]; generateMaterials(directory); // make mesh generateMesh(); // cleanup file.close(); // init graphics gfxInit(); }
bool NavMesh::buildProcess() { mBuilding = true; // Create mesh bool success = generateMesh(); mNavMeshLock.lock(); // Copy new navmesh into old. dtNavMesh *old = nm; nm = tnm; // I am trusting that this is atomic. dtFreeNavMesh(old); tnm = NULL; mNavMeshLock.unlock(); // Free structs used during build freeIntermediates(false); // Alert event manager that we have been built. if(mEventManager) mEventManager->postEvent("NavMeshBuild", ""); mBuilding = false; return success; }
Mesh::Mesh(string filename) { checksum = false; status_msg = ""; if (filename == "random" || filename == "random extrude" || filename == "random surfrev") { checksum = true; status_msg = "Success!"; randomMesh(filename); generateMesh(); } else if (fileParser(filename)) { checksum = true; status_msg = "Success!"; generateMesh(); } }
void Surface3d::generate(int width, int depth, float amplitude, int frequency, unsigned int seed) { surface = Matrix(depth, vector<propierties> (width)); Surface S(depth+1, width+1); S.perlinNoise(amplitude, frequency, seed); setGeometricPropierties(S); generateMesh(S); }
void LayerRenderer::finish() { OpenGLRenderer::finish(); generateMesh(); LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->getFbo()); // No need to unbind our FBO, this will be taken care of by the caller // who will invoke OpenGLRenderer::resume() }
//! Reads attributes of the scene node. void CSkyDomeSceneNode::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) { HorizontalResolution = in->getAttributeAsInt ("HorizontalResolution"); VerticalResolution = in->getAttributeAsInt ("VerticalResolution"); TexturePercentage = in->getAttributeAsFloat("TexturePercentage"); SpherePercentage = in->getAttributeAsFloat("SpherePercentage"); Radius = in->getAttributeAsFloat("Radius"); ISceneNode::deserializeAttributes(in, options); // regenerate the mesh generateMesh(); }
void OctreeSDF::generateTriangleCache() { auto mesh = generateMesh(); auto transformedMesh = std::make_shared<TransformedMesh>(mesh); std::cout << "Computing cache" << std::endl; mesh->computeTriangleNormals(); transformedMesh->computeCache(); m_TriangleCache.clearMeshes(); m_TriangleCache.addMesh(transformedMesh); std::cout << "Generating BVH" << std::endl; m_TriangleCache.generateBVH<AABB>(); std::cout << "Finished generating BVH" << std::endl; }
GLBaseGridNode::GLBaseGridNode(glm::vec3 min, glm::vec3 max, std::vector<int>* indexes, GLMeshHandler* handler, EDLogger* logger) { this->min = glm::vec3(min); this->max = glm::vec3(max); visible = INVISIBLE; int inside = 0; int totalV = 0; nodeColor = glm::vec3(rand() % 255 / 255.f, rand() % 255 / 255.f, rand() % 255 / 255.f); char logLine[128]; sprintf(logLine, "Node color: %f %f %f", VEC3_PRINT(nodeColor)); logger->logLineTimestamp(logLine); numMeshes = handler->numMeshes; //Verifica o que pertence e o que não localIndexes = new std::vector<int>[numMeshes]; for (int i = 0; i < numMeshes; i++) { localIndexes[i].clear(); GLMesh3D* mesh = &handler->meshes.at(i); for (int j = 0; j < indexes->size();) { glm::vec3* p1 = &mesh->vertexes[indexes->at(j)]; glm::vec3* p2 = &mesh->vertexes[indexes->at(j + 1)]; glm::vec3* p3 = &mesh->vertexes[indexes->at(j + 2)]; if (TriangleCube::testIntersection(p1, p2, p3, &this->min, &this->max)) { localIndexes[i].push_back(indexes->at(j)); localIndexes[i].push_back(indexes->at(j + 1)); localIndexes[i].push_back(indexes->at(j + 2)); inside += 3; } j += 3; } } sprintf(logLine, "Inside: %d/%d", inside, totalV); numIndicesTotal = inside; logger->logLineTimestamp(logLine); generateMesh(handler, logger); }
void testApp::setup() { ofSetFrameRate(60); ofSetVerticalSync(true); ofEnableNormalizedTexCoords(); ofDisableArbTex(); graph.allocate(1200, 400, OF_IMAGE_COLOR); buffer.allocate(1200,400,GL_RGBA,1); testImg2.loadImage("graph.png"); ofEnableSmoothing(); center = ofVec3f(); setupUI(); setupVar(); setupTCP(); generateMesh(&points); }
//----------------------------------------------------------------------- void CEnvironmentMap::initMesh(LPD3DXPATCHMESH pMesh, FLOAT fTessLevel) { f32 start = 8, span = 8; f32 x = -start, z = start; for (int i = 0; i < s_ObjCount; i++) { generateMesh(pMesh, &mEnvironmentObj[i].mesh, fTessLevel); OwnVector3 pos(x, 0, z); mEnvironmentObj[i].modelMtx.makeTrans(pos); x += span; if (x > start) { x = -start; z -= span; } } }
QString MeshGenerator::start(VolumeFileManager *vfm, int nX, int nY, int nZ, Vec dataMin, Vec dataMax, QString prevDir, Vec voxelScaling, int samplingLevel, QList<Vec> clipPos, QList<Vec> clipNormal, QList<CropObject> crops, QList<PathObject> paths, uchar *lut, int pruneLod, int pruneX, int pruneY, int pruneZ, QVector<uchar> pruneData, QVector<uchar> tagColors) { m_vfm = vfm; m_voxelType = m_vfm->voxelType(); m_depth = nX; m_width = nY; m_height = nZ; m_dataMin = dataMin; m_dataMax = dataMax; m_dataSize = m_dataMax - m_dataMin + Vec(1,1,1); m_nX = qMin(int(m_dataSize.z), m_depth); m_nY = qMin(int(m_dataSize.y), m_width); m_nZ = qMin(int(m_dataSize.x), m_height); m_crops = crops; m_paths = paths; m_pruneLod = pruneLod; m_pruneX = pruneX; m_pruneY = pruneY; m_pruneZ = pruneZ; m_pruneData = pruneData; m_tagColors = tagColors; m_samplingLevel = samplingLevel; // pruneLod that we get is wrt the original sized volume. // set pruneLod to reflect the selected sampling level. m_pruneLod = qMax((float)m_nX/(float)m_pruneZ, qMax((float)m_nY/(float)m_pruneY, (float)m_nZ/(float)m_pruneX)); // QMessageBox::information(0, "", QString("%1 %2 %3\n%4 %5 %6\n%7").\ // arg(m_nX).arg(m_nY).arg(m_nZ).\ // arg(m_pruneZ).arg(m_pruneY).arg(m_pruneX).\ // arg(m_pruneLod)); bool doBorder = false; if (qRound(m_dataSize.x) < m_height || qRound(m_dataSize.y) < m_width || qRound(m_dataSize.z) < m_depth) doBorder = true; if (clipPos.count() > 0 || m_crops.count() > 0 || m_paths.count() > 0) doBorder = true; int depth, fillValue; bool checkForMore; bool lookInside; QGradientStops stops; int chan; bool avgColor; if (! getValues(depth, fillValue, checkForMore, lookInside, stops, doBorder, chan, avgColor)) return ""; m_meshLog = new QTextEdit; m_meshProgress = new QProgressBar; QVBoxLayout *meshLayout = new QVBoxLayout; meshLayout->addWidget(m_meshLog); meshLayout->addWidget(m_meshProgress); QWidget *meshWindow = new QWidget; meshWindow->setWindowTitle("Drishti - Mesh Repainting Using Voxel Values"); meshWindow->setLayout(meshLayout); meshWindow->show(); meshWindow->resize(700, 300); float memGb = 0.5; memGb = QInputDialog::getDouble(0, "Use memory", "Max memory we can use (GB)", memGb, 0.1, 1000, 2); qint64 gb = 1024*1024*1024; qint64 memsize = memGb*gb; // max memory we can use (in GB) qint64 canhandle = memsize/15; qint64 gsize = qPow((double)canhandle, 0.333); m_meshLog->insertPlainText(QString("Can handle data with total grid size of %1 : typically %2^3\nOtherwise slabs method will be used. Mesh is generated for each slab and then joined together.\n\n"). \ arg(canhandle).arg(gsize)); m_meshLog->insertPlainText("\n\n"); m_meshLog->insertPlainText(QString("Volume Size : %1 %2 %3\n").\ arg(m_depth). arg(m_width). arg(m_height)); m_meshLog->insertPlainText(QString("DataMin : %1 %2 %3\n").\ arg(m_dataMin.z). arg(m_dataMin.y). arg(m_dataMin.x)); m_meshLog->insertPlainText(QString("DataMax : %1 %2 %3\n").\ arg(m_dataMax.z). arg(m_dataMax.y). arg(m_dataMax.x)); m_meshLog->insertPlainText(QString("DataSize : %1 %2 %3\n").\ arg(m_dataSize.z). arg(m_dataSize.y). arg(m_dataSize.x)); m_meshLog->insertPlainText("\n\n"); m_meshLog->insertPlainText(QString("Grid size : %1 %2 %3\n").\ arg(m_nX).arg(m_nY).arg(m_nZ)); //---- import the mesh --- QString inflnm = QFileDialog::getOpenFileName(0, "Load mesh to repaint", prevDir, "*.ply"); if (inflnm.size() == 0) { meshWindow->close(); return ""; } if (!loadPLY(inflnm)) { meshWindow->close(); return ""; } //---------------------------- //---- export the mesh --- QString outflnm = QFileDialog::getSaveFileName(0, "Export mesh", prevDir, "*.ply"); if (outflnm.size() == 0) { meshWindow->close(); return ""; } //---------------------------- int nSlabs = 1; qint64 reqmem = m_nX; reqmem *= m_nY*m_nZ*20; nSlabs = qMax(qint64(1), reqmem/memsize + 1); // QMessageBox::information(0, "", QString("Number of Slabs : %1 : %2 %3").\ // arg(nSlabs).arg(reqmem).arg(memsize)); QStringList volumeFiles; #ifndef Q_OS_MACX volumeFiles = QFileDialog::getOpenFileNames(0, "Load volume files for timeseries data, otherwise give CANCEL", prevDir, "NetCDF Files (*.pvl.nc)", 0, QFileDialog::DontUseNativeDialog); #else volumeFiles = QFileDialog::getOpenFileNames(0, "Load volume files for timeseries data, otherwise give CANCEL", prevDir, "NetCDF Files (*.pvl.nc)", 0); #endif int nvols = volumeFiles.count(); if (nvols == 0) volumeFiles << m_vfm->fileName(); generateMesh(nSlabs, volumeFiles, outflnm, depth, stops, fillValue, checkForMore, lookInside, voxelScaling, clipPos, clipNormal, crops, paths, lut, chan, avgColor); meshWindow->close(); return outflnm; }
ccRasterizeTool::ccRasterizeTool(ccGenericPointCloud* cloud, QWidget* parent/*=0*/) : QDialog(parent, Qt::WindowMaximizeButtonHint) , cc2Point5DimEditor() , Ui::RasterizeToolDialog() , m_cloud(cloud) { setupUi(this); #ifndef CC_GDAL_SUPPORT generateRasterPushButton->setDisabled(true); generateRasterPushButton->setChecked(false); #endif connect(buttonBox, SIGNAL(accepted()), this, SLOT(testAndAccept())); connect(buttonBox, SIGNAL(rejected()), this, SLOT(testAndReject())); connect(gridStepDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(updateGridInfo())); connect(gridStepDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(gridOptionChanged())); connect(emptyValueDoubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(gridOptionChanged())); connect(resampleCloudCheckBox, SIGNAL(toggled(bool)), this, SLOT(gridOptionChanged())); connect(dimensionComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(projectionDirChanged(int))); connect(heightProjectionComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(projectionTypeChanged(int))); connect(scalarFieldProjection, SIGNAL(currentIndexChanged(int)), this, SLOT(sfProjectionTypeChanged(int))); connect(fillEmptyCellsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(fillEmptyCellStrategyChanged(int))); connect(updateGridPushButton, SIGNAL(clicked()), this, SLOT(updateGridAndDisplay())); connect(generateCloudPushButton, SIGNAL(clicked()), this, SLOT(generateCloud())); connect(generateImagePushButton, SIGNAL(clicked()), this, SLOT(generateImage())); connect(generateRasterPushButton, SIGNAL(clicked()), this, SLOT(generateRaster())); connect(generateASCIIPushButton, SIGNAL(clicked()), this, SLOT(generateASCIIMatrix())); connect(generateMeshPushButton, SIGNAL(clicked()), this, SLOT(generateMesh())); connect(generateContoursPushButton, SIGNAL(clicked()), this, SLOT(generateContours())); connect(exportContoursPushButton, SIGNAL(clicked()), this, SLOT(exportContourLines())); connect(clearContoursPushButton, SIGNAL(clicked()), this, SLOT(removeContourLines())); connect(activeLayerComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(activeLayerChanged(int))); //custom bbox editor ccBBox gridBBox = m_cloud ? m_cloud->getOwnBB() : ccBBox(); if (gridBBox.isValid()) { createBoundingBoxEditor(gridBBox, this); connect(editGridToolButton, SIGNAL(clicked()), this, SLOT(showGridBoxEditor())); } else { editGridToolButton->setEnabled(false); } if (m_cloud) { cloudNameLabel->setText(m_cloud->getName()); pointCountLabel->setText(QString::number(m_cloud->size())); interpolateSFFrame->setEnabled(cloud->hasScalarFields()); //populate layer box activeLayerComboBox->addItem(GetDefaultFieldName(PER_CELL_HEIGHT)); if (cloud->isA(CC_TYPES::POINT_CLOUD) && cloud->hasScalarFields()) { ccPointCloud* pc = static_cast<ccPointCloud*>(cloud); for (unsigned i=0; i<pc->getNumberOfScalarFields(); ++i) activeLayerComboBox->addItem(pc->getScalarField(i)->getName()); } else { activeLayerComboBox->setEnabled(false); } //add window create2DView(mapFrame); } loadSettings(); updateGridInfo(); gridIsUpToDate(false); }
void ChunkBase::generateEntityMesh() { generateMesh(); mMeshGenerated = true; }
} LVRReconstructViaMarchingCubesDialog::~LVRReconstructViaMarchingCubesDialog() { m_master = 0; lvr::ProgressBar::setProgressCallback(0); lvr::ProgressBar::setProgressTitleCallback(0); } void LVRReconstructViaMarchingCubesDialog::connectSignalsAndSlots() { QObject::connect(m_dialog->comboBox_pcm, SIGNAL(currentIndexChanged(const QString)), this, SLOT(toggleRANSACcheckBox(const QString))); QObject::connect(m_dialog->comboBox_gs, SIGNAL(currentIndexChanged(int)), this, SLOT(switchGridSizeDetermination(int))); QObject::connect(m_dialog->buttonBox, SIGNAL(accepted()), this, SLOT(generateMesh())); } void LVRReconstructViaMarchingCubesDialog::toggleRANSACcheckBox(const QString &text) { QCheckBox* ransac_box = m_dialog->checkBox_RANSAC; if(text == "PCL") { ransac_box->setChecked(false); ransac_box->setCheckable(false); } else { ransac_box->setCheckable(true); } }
//============================================================================== // MAIN int main( int argc, char* argv[] ) { // spatial dimension const unsigned dim = SPACEDIM; typedef base::solver::Eigen3 Solver; // Check input arguments if ( argc != 2 ) { std::cerr << "Usage: " << argv[0] << " input.dat\n" << "(Compiled for dim=" << dim << ")\n\n"; return -1; } // read name of input file const std::string inputFile = boost::lexical_cast<std::string>( argv[1] ); const InputNucleus<dim> ui( inputFile ); // Simulation attributes const bool simplex = false; const bool stokesStabil = false; typedef mat::hypel::NeoHookeanCompressible Material; typedef TypesAndAttributes<dim,simplex> TA; // basic attributes of the computation base::auxi::BoundingBox<dim> bbox( ui.bbmin, ui.bbmax ); TA::Mesh mesh; generateMesh( mesh, ui ); // Creates a list of <Element,faceNo> pairs base::mesh::MeshBoundary meshBoundary; meshBoundary.create( mesh.elementsBegin(), mesh.elementsEnd() ); TA::BoundaryMesh boundaryMesh; base::mesh::generateBoundaryMesh( meshBoundary.begin(), meshBoundary.end(), mesh, boundaryMesh ); // mesh size (all equal, more or less) const double h = base::mesh::Size<TA::Mesh::Element>::apply( mesh.elementPtr(0) ); //-------------------------------------------------------------------------- typedef base::cut::LevelSet<dim> LevelSet; std::vector<LevelSet> levelSetNucleus, levelSetMembrane; base::cut::analyticLevelSet( mesh, base::cut::Sphere<dim>( ui.RN, ui.centerN ), true, levelSetNucleus ); base::cut::analyticLevelSet( mesh, base::cut::Sphere<dim>( ui.RM, ui.centerM ), true, levelSetMembrane ); //-------------------------------------------------------------------------- // make cut cell structures std::vector<TA::Cell> cellsNucleus, cellsMembrane, cellsCS; base::cut::generateCutCells( mesh, levelSetNucleus, cellsNucleus ); base::cut::generateCutCells( mesh, levelSetMembrane, cellsMembrane ); { cellsCS = cellsNucleus; std::for_each( cellsCS.begin(), cellsCS.end(), boost::bind( &TA::Cell::reverse, _1 ) ); base::cut::generateCutCells( mesh, levelSetMembrane, cellsCS, base::cut::INTERSECT ); } // intersection with the box boundary std::vector<TA::SurfCell> surfaceCells; base::cut::generateCutCells( boundaryMesh, levelSetMembrane, surfaceCells ); // Elastic material Material material( mat::Lame::lambda( ui.E, ui.nu), mat::Lame::mu( ui.E, ui.nu ) ); // Solid and fluid handlers typedef Solid<TA::Mesh, Material> Solid; typedef Fluid<TA::Mesh, stokesStabil> Fluid; typedef SolidFluidInterface<TA::SurfaceMesh,Solid,Fluid> SFI; typedef FluidFluidInterface<TA::SurfaceMesh,Fluid> FFI; Solid nucleus( mesh, material ); Fluid gel( mesh, ui.viscosityGel, ui.alpha ); Fluid cytoSkeleton( mesh, ui.viscosityCS, ui.alpha ); // find geometry association for the dofs std::vector<std::pair<std::size_t,TA::VecDim> > doFLocationD, doFLocationU; base::dof::associateLocation( nucleus.getDisplacement(), doFLocationD ); base::dof::associateLocation( gel.getVelocity(), doFLocationU ); // Quadrature along a surface TA::CutQuadrature cutQuadratureNucleus( cellsNucleus, true ); TA::CutQuadrature cutQuadratureGel( cellsMembrane, false ); TA::CutQuadrature cutQuadratureCS( cellsCS, true ); TA::SurfaceQuadrature surfaceQuadrature; TA::SurfCutQuadrature surfaceCutQuadrature( surfaceCells, true ); //-------------------------------------------------------------------------- // Run a zero-th step in order to write the data before computation // (store the previously enclosed volume) double prevVolumeN, initialVolumeCS; { std::cout << 0 << " " << 0. << " 0 " << std::flush; writeVTKFile( "nucleus", 0, mesh, nucleus.getDisplacement(), cytoSkeleton.getVelocity(), cytoSkeleton.getPressure(), gel.getVelocity(), gel.getPressure(), levelSetNucleus, levelSetMembrane, ui.dt ); // for surface field TA::SurfaceMesh membrane, envelope; base::cut::generateSurfaceMesh<TA::Mesh,TA::Cell>( mesh, cellsMembrane, membrane ); base::cut::generateSurfaceMesh<TA::Mesh,TA::Cell>( mesh, cellsNucleus, envelope ); writeSurfaceVTKFile( "membrane", 0, membrane ); writeSurfaceVTKFile( "envelope", 0, envelope ); surfaceFeatures( boundaryMesh, membrane, envelope, surfaceQuadrature, surfaceCutQuadrature, std::cout ); std::cout << std::endl; // store the contained volume prevVolumeN = surf::enclosedVolume( envelope, surfaceQuadrature ); initialVolumeCS = surf::enclosedVolume( membrane, surfaceQuadrature ) + surf::enclosedVolume( boundaryMesh, surfaceCutQuadrature ); } //-------------------------------------------------------------------------- // * Loop over time steps * //-------------------------------------------------------------------------- const double supportThreshold = std::numeric_limits<double>::min(); for ( unsigned step = 0; step < ui.numLoadSteps; step++ ) { // for surface field TA::SurfaceMesh membrane, envelope; base::cut::generateSurfaceMesh<TA::Mesh,TA::Cell>( mesh, cellsMembrane, membrane ); base::cut::generateSurfaceMesh<TA::Mesh,TA::Cell>( mesh, cellsNucleus, envelope ); // Interface handler SFI envelopeHandler( envelope, nucleus.getDisplacement(), cytoSkeleton.getVelocity(), cytoSkeleton.getPressure(), ui.viscosityCS ); FFI membraneHandler( membrane, cytoSkeleton.getVelocity(), cytoSkeleton.getPressure(), gel.getVelocity(), gel.getPressure(), cellsMembrane, ui.viscosityCS, ui.viscosityGel, ui.sigma ); std::cout << step+1 << " " << (step+1) * ui.dt << " " << std::flush; //---------------------------------------------------------------------- // 0) Solve Lagrangian problem // compute supports std::vector<double> supportsD, supportsUCS, supportsPCS, supportsUGel, supportsPGel; base::cut::supportComputation( mesh, nucleus.getDisplacement(), cutQuadratureNucleus, supportsD ); base::cut::supportComputation( mesh, cytoSkeleton.getVelocity(), cutQuadratureCS, supportsUCS ); base::cut::supportComputation( mesh, cytoSkeleton.getPressure(), cutQuadratureCS, supportsPCS ); base::cut::supportComputation( mesh, gel.getVelocity(), cutQuadratureGel, supportsUGel ); base::cut::supportComputation( mesh, gel.getPressure(), cutQuadratureGel, supportsPGel ); // Hard-wired Dirichlet constraints (fluid BC) { // apply to outer material = gel base::dof::constrainBoundary<Fluid::FEBasisU>( meshBoundary.begin(), meshBoundary.end(), mesh, gel.getVelocity(), boost::bind( &dirichletBC<dim,Fluid::DoFU>, _1, _2, ui.ubar, bbox, ui.bc ) ); // in case of boundary intersections, apply to cytoskeleton base::dof::constrainBoundary<Fluid::FEBasisU>( meshBoundary.begin(), meshBoundary.end(), mesh, cytoSkeleton.getVelocity(), boost::bind( &dirichletBC<dim,Fluid::DoFU>, _1, _2, ui.ubar, bbox, ui.bc ) ); // Fix first pressure dof in case of closed cavity flow if ( ui.bc == CAVITY ) { Fluid::Pressure::DoFPtrIter pIter = gel.getPressure().doFsBegin(); (*pIter) -> constrainValue( 0, 0.0 ); } } // Basis stabilisation base::cut::stabiliseBasis( mesh, nucleus.getDisplacement(), supportsD, doFLocationD ); base::cut::stabiliseBasis( mesh, cytoSkeleton.getVelocity(), supportsUCS, doFLocationU ); base::cut::stabiliseBasis( mesh, cytoSkeleton.getPressure(), supportsPCS, doFLocationD ); base::cut::stabiliseBasis( mesh, gel.getVelocity(), supportsUGel, doFLocationU ); base::cut::stabiliseBasis( mesh, gel.getPressure(), supportsPGel, doFLocationD ); // number DoFs const std::size_t activeDoFsD = base::dof::numberDoFsConsecutively( nucleus.getDisplacement().doFsBegin(), nucleus.getDisplacement().doFsEnd() ); const std::size_t activeDoFsUCS = base::dof::numberDoFsConsecutively( cytoSkeleton.getVelocity().doFsBegin(), cytoSkeleton.getVelocity().doFsEnd(), activeDoFsD ); const std::size_t activeDoFsPCS = base::dof::numberDoFsConsecutively( cytoSkeleton.getPressure().doFsBegin(), cytoSkeleton.getPressure().doFsEnd(), activeDoFsD + activeDoFsUCS ); const std::size_t activeDoFsUGel = base::dof::numberDoFsConsecutively( gel.getVelocity().doFsBegin(), gel.getVelocity().doFsEnd(), activeDoFsD + activeDoFsUCS + activeDoFsPCS ); const std::size_t activeDoFsPGel = base::dof::numberDoFsConsecutively( gel.getPressure().doFsBegin(), gel.getPressure().doFsEnd(), activeDoFsD + activeDoFsUCS + activeDoFsPCS + activeDoFsUGel ); // start from 0 for the increments, set rest to zero too base::dof::clearDoFs( nucleus.getDisplacement() ); base::dof::clearDoFs( cytoSkeleton.getPressure() ); base::dof::clearDoFs( cytoSkeleton.getVelocity() ); base::dof::clearDoFs( gel.getPressure() ); base::dof::clearDoFs( gel.getVelocity() ); //---------------------------------------------------------------------- // Nonlinear iterations unsigned iter = 0; for ( ; iter < ui.maxIter; iter++ ) { // Create a solver object Solver solver( activeDoFsD + activeDoFsUCS + activeDoFsPCS + activeDoFsUGel + activeDoFsPGel ); // register to solver nucleus.registerInSolver( solver ); cytoSkeleton.registerInSolver( solver ); gel.registerInSolver( solver ); membraneHandler.registerInSolver( solver ); envelopeHandler.registerInSolver( solver ); // Compute as(d,dd) and Da(d,dd)[Delta d] nucleus.assembleBulk( cutQuadratureNucleus, solver, iter ); // Body force nucleus.bodyForce( cutQuadratureNucleus, solver, boost::bind( unitForce<0,dim>, _1, ui.forceValue ) ); // Computate af(u,p; du,dp) cytoSkeleton.assembleBulk( cutQuadratureCS, solver ); gel.assembleBulk( cutQuadratureGel, solver ); // Penalty terms for int_Gamma (dot(d) - u) (E delta d - mu delta u) ds envelopeHandler.assemblePenaltyTerms( surfaceQuadrature, solver, ui.penaltyFac, ui.dt ); membraneHandler.assemblePenaltyTerms( surfaceQuadrature, solver, ui.penaltyFac ); // Boundary energy terms (beta = 0) [ -int_Gamma (...) ds ] envelopeHandler.assembleEnergyTerms( surfaceQuadrature, solver, ui.dt ); membraneHandler.assembleEnergyTerms( surfaceQuadrature, solver ); // surface tension membraneHandler.surfaceTension( surfaceQuadrature, solver ); // Finalise assembly solver.finishAssembly(); // norm of residual const double conv1 = solver.norm(0, activeDoFsD) / ui.E; if ( isnan( conv1 ) ) return 1; if ( ( iter > 0 ) and ( conv1 < ui.tolerance ) ) { std::cout << "schon" << std::endl; break; } // Solve #ifdef LOAD_PARDISO solver.pardisoLUSolve(); #else #ifdef LOAD_UMFPACK solver.umfPackLUSolve(); #else solver.superLUSolve(); //solver.biCGStabSolve(); #endif #endif // distribute results back to dofs base::dof::addToDoFsFromSolver( solver, nucleus.getDisplacement() ); //<> base::dof::setDoFsFromSolver( solver, cytoSkeleton.getVelocity() ); base::dof::setDoFsFromSolver( solver, cytoSkeleton.getPressure() ); base::dof::setDoFsFromSolver( solver, gel.getVelocity() ); base::dof::setDoFsFromSolver( solver, gel.getPressure() ); const double conv2 = solver.norm(0, activeDoFsD); if ( conv2 < ui.tolerance ) break; } // finish non-linear iteration std::cout << iter << " " << std::flush; // write a vtk file writeVTKFile( "nucleus", step+1, mesh, nucleus.getDisplacement(), cytoSkeleton.getVelocity(), cytoSkeleton.getPressure(), gel.getVelocity(), gel.getPressure(), levelSetNucleus, levelSetMembrane, ui.dt ); writeSurfaceVTKFile( "membrane", step+1, membrane ); writeSurfaceVTKFile( "envelope", step+1, envelope ); //---------------------------------------------------------------------- // 1) Pass Data to complementary domain of solid { const double extL = h; // extrapolation length // pass extrapolated solution to inactive DoFs extrapolateToFictitious( mesh, nucleus.getDisplacement(), extL, doFLocationD, levelSetNucleus, bbox ); } //---------------------------------------------------------------------- // 2) Geometry update // a) Nucleus { // get shape features const double volumeN = surf::enclosedVolume( envelope, surfaceQuadrature ); const TA::VecDim momentN = surf::enclosedVolumeMoment( envelope, surfaceQuadrature ); const TA::VecDim centroidN = momentN / volumeN; const double factorN = std::pow( prevVolumeN / volumeN, 1./static_cast<double>( dim ) ); // Move with velocity solution moveSurface( mesh, cytoSkeleton.getVelocity(), envelope, ui.dt, factorN, centroidN ); // compute new level set for envelope of nucleus base::cut::bruteForce( mesh, envelope, true, levelSetNucleus ); // update the cut cell structure base::cut::generateCutCells( mesh, levelSetNucleus, cellsNucleus ); // store the contained volume prevVolumeN = surf::enclosedVolume( envelope, surfaceQuadrature ); } // b) CS { // get shape features const double volumeCS = surf::enclosedVolume( membrane, surfaceQuadrature ) + surf::enclosedVolume( boundaryMesh, surfaceCutQuadrature ); const TA::VecDim momentCS = surf::enclosedVolumeMoment( membrane, surfaceQuadrature ) + surf::enclosedVolumeMoment( boundaryMesh, surfaceCutQuadrature ); const TA::VecDim centroidCS = momentCS / volumeCS; // Move with velocity solution moveSurface( mesh, gel.getVelocity(), membrane, ui.dt, 1.0, centroidCS ); // rescale in order to preserve initial volume rescaleSurface( membrane, initialVolumeCS, volumeCS, centroidCS ); // compute new level set for membrane base::cut::bruteForce( mesh, membrane, true, levelSetMembrane ); // update the cut cell structure base::cut::generateCutCells( mesh, levelSetMembrane, cellsMembrane ); base::cut::generateCutCells( boundaryMesh, levelSetMembrane, surfaceCells ); } // new structure for cytoskeleton { cellsCS = cellsNucleus; std::for_each( cellsCS.begin(), cellsCS.end(), boost::bind( &TA::Cell::reverse, _1 ) ); base::cut::generateCutCells( mesh, levelSetMembrane, cellsCS, base::cut::INTERSECT ); } //---------------------------------------------------------------------- // 3) advect data { base::cut::supportComputation( mesh, nucleus.getDisplacement(), cutQuadratureNucleus, supportsD ); // Find the location of the DoFs in the previous configuration std::vector<std::pair<std::size_t,TA::VecDim> > previousDoFLocation; findPreviousDoFLocations( mesh, nucleus.getDisplacement(), supportsD, doFLocationD, previousDoFLocation, bbox, supportThreshold, ui.findTolerance, 10 ); // add previous solution to current solution: u_{n+1} = \Delta u + u_n { Solid::Displacement::DoFPtrIter dIter = nucleus.getDisplacement().doFsBegin(); Solid::Displacement::DoFPtrIter dEnd = nucleus.getDisplacement().doFsEnd(); for ( ; dIter != dEnd; ++dIter ) { for ( unsigned d = 0; d < dim; d++ ) { const double prevU = (*dIter) -> getHistoryValue<1>( d ); const double deltaU = (*dIter) -> getHistoryValue<0>( d ); const double currU = prevU + deltaU; (*dIter) -> setValue( d, currU ); } } } // advect displacement field from previous to new location advectField( mesh, nucleus.getDisplacement(), previousDoFLocation, supportsD, supportThreshold ); } //---------------------------------------------------------------------- // push history base::dof::pushHistory( nucleus.getDisplacement() ); // remove the linear constraints used in the stabilisation process base::dof::clearConstraints( nucleus.getDisplacement() ); base::dof::clearConstraints( cytoSkeleton.getVelocity() ); base::dof::clearConstraints( cytoSkeleton.getPressure() ); base::dof::clearConstraints( gel.getVelocity() ); base::dof::clearConstraints( gel.getPressure() ); surfaceFeatures( boundaryMesh, membrane, envelope, surfaceQuadrature, surfaceCutQuadrature, std::cout ); std::cout << std::endl; } // end load-steps return 0; }
std::vector<Point3f> skelpath::reconstruct() { // return point cloud std::vector<Point3f> points ; if( solvers.size() == 0 ){ if( tempalteIdss.size() == 0) return points ; solvers = generateJointSetting() ; } jointSettingNum = solvers.size() ; cutplanes_bp.clear() ; cutplanes_bp.resize( solvers.size() ) ; branches_bp.clear() ; branches_bp.resize( solvers.size() ) ; subpoints.clear() ; resultProf3d.clear() ; resultProf2d.clear() ; for( int iter =0; iter<solvers.size(); ++iter ){ std::cout<<"iter="<<iter<<std::endl; completionSolver &comSolver = solvers[iter]; char tmp[10] ; std::string xfilename = std::string("x") + std::string( itoa(iter, tmp,10) )+".txt" ; std::ifstream xifs(xfilename) ; std::vector<double> inx,outx ; //double tt ; //while( xifs >> tt ) // inx.push_back(tt); outx = comSolver.solve( inx ) ; std::ofstream xofs(xfilename) ; for( int i=0;i<outx.size(); ++i ) xofs << outx[i] << std::endl; xofs.close() ; xifs.close() ; std::cout<<"mark--------1" <<std::endl; std::vector<cutPlane> cutpls = comSolver.cutplanes ; std::vector<Point3f> brch = comSolver.centers ; std::vector<std::vector<Point3f>> profiles3d ; std::vector<std::vector<Point2f>> profiles2d ; for( int i=0; i<comSolver.finalProfiles.size(); ++i ){ Profile3D p3d = ReconstructorUtility::convert2dProfileTo3d( comSolver.finalProfiles[i], cutpls[i], brch[i] ) ; profiles3d.push_back( p3d ) ; profiles2d.push_back( comSolver.finalProfiles[i] ) ; // store cutplane and plnormal of branch pairs for debuging cutplanes_bp[iter].push_back(cutpls[i] ); branches_bp[iter].push_back(brch[i] ); } resultProf3d.push_back( profiles3d ) ; resultProf2d.push_back( profiles2d ) ; std::cout<<"mark--------2" <<std::endl; std::vector<Point3f> subpoint = ReconstructorUtility::upsampleResult( profiles3d, int2(0, brch.size()-1 ), comSolver.firstIsTip, comSolver.lastIsTip ) ; points.insert(points.begin(), subpoint.begin(), subpoint.end() ) ; subpoints.push_back( subpoint ) ; // for blend std::cout<<"mark--------3" <<std::endl; // store control points extern std::vector<Point3f > globalPointsToDraw1 ; for( int i=0; i<comSolver.finalCtrPoints.size(); ++i ) for( int j=0; j<comSolver.finalCtrPoints[i].size(); ++j ) globalPointsToDraw1.push_back( comSolver.finalCtrPoints[i][j] ) ; // store sharp features extern std::vector<Point3f > globalPointsToDraw2 ; for( int i=0; i<comSolver.finalCtrPoints.size(); ++i ) for( int k=0; k<comSolver.sharpIds[0].size(); ++k) globalPointsToDraw2.push_back( comSolver.finalCtrPoints[i][comSolver.sharpIds[0][k]] ) ; } generateMesh() ; return points ; }
void generate() { // create 12 vertices of a icosahedron double t = (1 + std::sqrt(5)) / 2; vertexList_.push_back(utymap::meshing::Vector3(-1, t, 0).normalized()); vertexList_.push_back(utymap::meshing::Vector3(1, t, 0).normalized()); vertexList_.push_back(utymap::meshing::Vector3(-1, -t, 0).normalized()); vertexList_.push_back(utymap::meshing::Vector3(1, -t, 0).normalized()); vertexList_.push_back(utymap::meshing::Vector3(0, -1, t).normalized()); vertexList_.push_back(utymap::meshing::Vector3(0, 1, t).normalized()); vertexList_.push_back(utymap::meshing::Vector3(0., -1, -t).normalized()); vertexList_.push_back(utymap::meshing::Vector3(0, 1, -t).normalized()); vertexList_.push_back(utymap::meshing::Vector3(t, 0, -1).normalized()); vertexList_.push_back(utymap::meshing::Vector3(t, 0, 1).normalized()); vertexList_.push_back(utymap::meshing::Vector3(-t, 0, -1).normalized()); vertexList_.push_back(utymap::meshing::Vector3(-t, 0, 1).normalized()); // create 20 triangles of the icosahedron std::vector<TriangleIndices> faces; // 5 faces around point 0 faces.push_back(TriangleIndices(0, 11, 5)); faces.push_back(TriangleIndices(0, 5, 1)); faces.push_back(TriangleIndices(0, 1, 7)); faces.push_back(TriangleIndices(0, 7, 10)); faces.push_back(TriangleIndices(0, 10, 11)); // 5 adjacent faces faces.push_back(TriangleIndices(1, 5, 9)); faces.push_back(TriangleIndices(5, 11, 4)); if (!isSemiSphere_) faces.push_back(TriangleIndices(11, 10, 2)); faces.push_back(TriangleIndices(10, 7, 6)); faces.push_back(TriangleIndices(7, 1, 8)); // 5 faces around point 3 if (!isSemiSphere_) { faces.push_back(TriangleIndices(3, 9, 4)); faces.push_back(TriangleIndices(3, 4, 2)); faces.push_back(TriangleIndices(3, 2, 6)); faces.push_back(TriangleIndices(3, 6, 8)); faces.push_back(TriangleIndices(3, 8, 9)); } // 5 adjacent faces faces.push_back(TriangleIndices(4, 9, 5)); if (!isSemiSphere_) { faces.push_back(TriangleIndices(2, 4, 11)); faces.push_back(TriangleIndices(6, 2, 10)); } faces.push_back(TriangleIndices(8, 6, 7)); faces.push_back(TriangleIndices(9, 8, 1)); // refine triangles for (int i = 0; i < recursionLevel_; i++) { std::vector<TriangleIndices> faces2; for (const auto& tri : faces) { // replace triangle by 4 triangles auto a = getMiddlePoint(tri.V1, tri.V2); auto b = getMiddlePoint(tri.V2, tri.V3); auto c = getMiddlePoint(tri.V3, tri.V1); faces2.push_back(TriangleIndices(tri.V1, a, c)); faces2.push_back(TriangleIndices(tri.V2, b, a)); faces2.push_back(TriangleIndices(tri.V3, c, b)); faces2.push_back(TriangleIndices(a, b, c)); } faces = faces2; } generateMesh(faces); // clear state to allow reusage middlePointIndexCache_.clear(); vertexList_.clear(); }
void MarchingCube::update() { updateDensityField(); generateMesh(); }
void testApp::update(){ updateConditions(); generateTexture(); generateMesh(&points); updateTexture(); }