From 0bde78ee7dd64b3d68cd0a206c171612b678e0e3 Mon Sep 17 00:00:00 2001 From: djairoh Date: Tue, 7 May 2024 15:46:54 +0200 Subject: [PATCH] feat: beaching of particles --- .../src/commands/SpawnPointCallback.cpp | 6 + .../src/commands/SpawnPointCallback.h | 3 + .../src/layers/LGlyphLayer.cpp | 103 ++++++++++++++---- .../src/layers/LGlyphLayer.h | 2 + 4 files changed, 92 insertions(+), 22 deletions(-) diff --git a/particle-track-and-trace/src/commands/SpawnPointCallback.cpp b/particle-track-and-trace/src/commands/SpawnPointCallback.cpp index b14b6e2..e0c793e 100644 --- a/particle-track-and-trace/src/commands/SpawnPointCallback.cpp +++ b/particle-track-and-trace/src/commands/SpawnPointCallback.cpp @@ -42,9 +42,11 @@ void SpawnPointCallback::Execute(vtkObject *caller, unsigned long evId, void *ca inverseCartographicProjection->MultiplyPoint(worldPos, worldPos); points->InsertNextPoint(worldPos[0], worldPos[1], 0); + this->particlesBeached->InsertNextValue(0); // FIXME: The below lines cause some weird interaction with our vtkTimer. // see github issue https://github.com/MakeNEnjoy/interactive-track-and-trace/issues/28 + this->particlesBeached->Modified(); this->points->Modified(); ren->GetRenderWindow()->Render(); } @@ -76,3 +78,7 @@ void SpawnPointCallback::setUVGrid(const std::shared_ptr &uvGrid) { inverseCartographicProjection = getCartographicTransformMatrix(uvGrid); inverseCartographicProjection->Invert(); } + +void SpawnPointCallback::setBeached(const vtkSmartPointer &ints) { + this->particlesBeached = ints; +} diff --git a/particle-track-and-trace/src/commands/SpawnPointCallback.h b/particle-track-and-trace/src/commands/SpawnPointCallback.h index b7f7682..da527ae 100644 --- a/particle-track-and-trace/src/commands/SpawnPointCallback.h +++ b/particle-track-and-trace/src/commands/SpawnPointCallback.h @@ -23,12 +23,15 @@ public: void setRen(const vtkSmartPointer &ren); + void setBeached(const vtkSmartPointer &parts); + void setUVGrid(const std::shared_ptr &uvGrid); private: vtkSmartPointer data; vtkSmartPointer points; vtkSmartPointer ren; + vtkSmartPointer particlesBeached; std::shared_ptr uvGrid; vtkSmartPointer inverseCartographicProjection; diff --git a/particle-track-and-trace/src/layers/LGlyphLayer.cpp b/particle-track-and-trace/src/layers/LGlyphLayer.cpp index 3a4077a..8d112a6 100644 --- a/particle-track-and-trace/src/layers/LGlyphLayer.cpp +++ b/particle-track-and-trace/src/layers/LGlyphLayer.cpp @@ -2,8 +2,10 @@ #include "../commands/SpawnPointCallback.h" #include #include +#include #include #include +#include #include #include #include @@ -20,16 +22,34 @@ vtkSmartPointer LGlyphLayer::createSpawnPointCallback() { auto newPointCallBack = vtkSmartPointer::New(); - newPointCallBack->setData(data); - newPointCallBack->setPoints(points); - newPointCallBack->setRen(ren); - newPointCallBack->setUVGrid(uvGrid); + newPointCallBack->setData(this->data); + newPointCallBack->setPoints(this->points); + newPointCallBack->setRen(this->ren); + newPointCallBack->setUVGrid(this->uvGrid); + newPointCallBack->setBeached(this->particlesBeached); return newPointCallBack; } // Further notes; current thinking is to allow tracking a particle's age by using a scalar array in the VtkPolyData. This would be incremented for every tick/updateData function call. -// Another challenge is the concept of beaching; dead particles must not be included in the advect function call (wasted computations), but they should not be outright deleted from the vtkPoints either (we still want to display them). Working Solution: have another array of ints in the vtkPolyData, which tracks for how many calls of UpdateData a given particle has not had its position changed. If this int reaches some treshold (5? 10? 3? needs some testing), exclude the particle from the advect call. -// TODO: modelling all this in vtkClasses is workable, but ideally i would want to work with a native C++ class. See if this is doable and feasible. + +/** + * Build and returns a vtkLookupTable for the given number of colours in grayscale. + * @param n : number of colours to add to the SetTableRange + * @return : a vtkLookupTable with grayscale colours from [1,1,1,1] to [0.5,0.5,0.5,0.5] in n steps. + */ +vtkSmartPointer buildLut(int n) { + vtkNew lut; + lut->SetNumberOfColors(n); + lut->SetTableRange(0, n-1); + lut->SetScaleToLinear(); + lut->Build(); + for (int i=0; i < n; i++) { + lut->SetTableValue(i, 1-(0.5*i/(n-1)), 1-(0.5*i/(n-1)), 1-(0.5*i/(n-1)), 1-(0.5*i/(n-1))); + } + // set the last value to separate fully beached particles from those that have simply not moved in a bit. + lut->SetTableValue(n-1, 0, 0, 0, 0.25); + return lut; +} LGlyphLayer::LGlyphLayer(std::shared_ptr uvGrid, std::unique_ptr advectionKernel) { this->ren = vtkSmartPointer::New(); @@ -39,6 +59,13 @@ LGlyphLayer::LGlyphLayer(std::shared_ptr uvGrid, std::unique_ptrdata = vtkSmartPointer::New(); this->data->SetPoints(this->points); + this->particlesBeached = vtkSmartPointer::New(); + this->particlesBeached->SetName("particlesBeached"); + this->particlesBeached->SetNumberOfComponents(0); + + this->data->GetPointData()->AddArray(this->particlesBeached); + this->data->GetPointData()->SetActiveScalars("particlesBeached"); + advector = std::move(advectionKernel); this->uvGrid = uvGrid; @@ -47,17 +74,19 @@ LGlyphLayer::LGlyphLayer(std::shared_ptr uvGrid, std::unique_ptr circleSource; circleSource->SetGlyphTypeToCircle(); - circleSource->SetScale(0.05); + circleSource->SetScale(0.02); circleSource->Update(); vtkNew glyph2D; glyph2D->SetSourceConnection(circleSource->GetOutputPort()); glyph2D->SetInputConnection(transformFilter->GetOutputPort()); - glyph2D->SetColorModeToColorByScalar(); + glyph2D->SetScaleModeToDataScalingOff(); glyph2D->Update(); vtkNew mapper; mapper->SetInputConnection(glyph2D->GetOutputPort()); + mapper->SetLookupTable(buildLut(this->beachedAtNumberOfTimes)); + mapper->SetScalarRange(0, this->beachedAtNumberOfTimes); mapper->Update(); vtkNew actor; @@ -66,17 +95,22 @@ LGlyphLayer::LGlyphLayer(std::shared_ptr uvGrid, std::unique_ptrren->AddActor(actor); } + // creates a few points so we can test the updateData function void LGlyphLayer::spoofPoints() { - this->points->InsertNextPoint(-4.125, 61.375 , 0); - // this->points->InsertNextPoint(6.532949683882039, 53.24308582564463, 0); // Coordinates of Zernike - // this->points->InsertNextPoint(5.315307819255385, 60.40001057122271, 0); // Coordinates of Bergen - // this->points->InsertNextPoint( 6.646210231365825, 46.52346296009023, 0); // Coordinates of Lausanne - // this->points->InsertNextPoint(-6.553894313570932, 62.39522131195857, 0); // Coordinates of the top of the Faroe islands + // auto id =this->points->InsertNextPoint(6.532949683882039, 53.24308582564463, 0); // Coordinates of Zernike + // this->particlesBeached->SetValue(id, 0); + // id = this->points->InsertNextPoint(5.315307819255385, 60.40001057122271, 0); // Coordinates of Bergen + // this->particlesBeached->SetValue(id, 0); + // id = this->points->InsertNextPoint( 6.646210231365825, 46.52346296009023, 0); // Coordinates of Lausanne + // this->particlesBeached->SetValue(id, 0); + // id = this->points->InsertNextPoint(-6.553894313570932, 62.39522131195857, 0); // Coordinates of the top of the Faroe islands + // this->particlesBeached->SetValue(id, 0); for (int i=0; i < 330; i+=5) { for (int j=0; j < 330; j+=5) { - this->points->InsertNextPoint(-15.875+(12.875+15.875)/330*j, 46.125+(62.625-46.125)/330*i, 0); + this->points->InsertNextPoint(-15.875+(12.875+15.875)/330*j, 46.125+(62.625-46.125)/330*i, 0); + this->particlesBeached->InsertNextValue(0); } } @@ -85,16 +119,41 @@ void LGlyphLayer::spoofPoints() { void LGlyphLayer::updateData(int t) { const int SUPERSAMPLINGRATE = 4; - double point[3]; - for (vtkIdType n = 0; n < this->points->GetNumberOfPoints(); n++) { - this->points->GetPoint(n, point); - for (int i = 0; i < SUPERSAMPLINGRATE; i++) { - std::tie(point[1], point[0]) = advector->advect(t, point[1], point[0], (t-lastT)/SUPERSAMPLINGRATE); + double point[3], oldX, oldY; + bool modifiedData = false; + + // iterate over every point. + for (vtkIdType n=0; n < this->points->GetNumberOfPoints(); n++) { + int beachedFor = this->particlesBeached->GetValue(n); + // first check: only update non-beached particles. + if (beachedFor < this->beachedAtNumberOfTimes) { + this->points->GetPoint(n, point); + // second check: only update points within our grid's boundary. + if (point[0] < this->uvGrid->lonMin() or point[0] > this->uvGrid->lonMax() or point[1] < this->uvGrid->latMin() or point[1] > this->uvGrid->latMax()) { + // sets any particle out of bounds to be beached - so it gets assigned the right colour in the lookup table. + this->particlesBeached->SetValue(n, this->beachedAtNumberOfTimes); + continue; + } + + oldX = point[0]; oldY = point[1]; + + // supersampling + for (int i=0; i < SUPERSAMPLINGRATE; i++) { + std::tie(point[1], point[0]) = advector->advect(t, point[1], point[0], (t-this->lastT)/SUPERSAMPLINGRATE); + } + + // if the particle's location remains unchanged, increase beachedFor number. Else, decrease it and update point position. + if (oldX == point[0] and oldY == point[1]) { + this->particlesBeached->SetValue(n, beachedFor+1); + } else { + this->particlesBeached->SetValue(n, std::max(beachedFor-1, 0)); + this->points->SetPoint(n, point); + modifiedData = true; + } } - this->points->SetPoint(n, point[0], point[1], 0); } - lastT = t; - this->points->Modified(); + if (modifiedData) this->points->Modified(); + this->lastT = t; } void LGlyphLayer::addObservers(vtkSmartPointer interactor) { diff --git a/particle-track-and-trace/src/layers/LGlyphLayer.h b/particle-track-and-trace/src/layers/LGlyphLayer.h index 125282f..91bc42a 100644 --- a/particle-track-and-trace/src/layers/LGlyphLayer.h +++ b/particle-track-and-trace/src/layers/LGlyphLayer.h @@ -14,9 +14,11 @@ class LGlyphLayer : public Layer { private: vtkSmartPointer points; vtkSmartPointer data; + vtkSmartPointer particlesBeached; std::unique_ptr advector; std::shared_ptr uvGrid; int lastT = 1000; + int beachedAtNumberOfTimes = 20; public: /** Constructor.