SPH
Factory.cpp
Go to the documentation of this file.
1 #include "gui/Factory.h"
2 #include "gui/Project.h"
3 #include "gui/objects/Camera.h"
4 #include "gui/objects/Colorizer.h"
5 #include "gui/renderers/Brdf.h"
6 #include "gui/renderers/ContourRenderer.h"
7 #include "gui/renderers/FrameBuffer.h"
8 #include "gui/renderers/MeshRenderer.h"
9 #include "gui/renderers/ParticleRenderer.h"
10 #include "gui/renderers/RayTracer.h"
11 #include "gui/renderers/VolumeRenderer.h"
12 
13 NAMESPACE_SPH_BEGIN
14 
15 AutoPtr<ITracker> Factory::getTracker(const GuiSettings& settings) {
16  const int trackedIndex = settings.get<int>(GuiSettingsId::CAMERA_TRACK_PARTICLE);
17  if (trackedIndex >= 0) {
18  return makeAuto<ParticleTracker>(trackedIndex);
19  }
20  const bool useMedian = settings.get<bool>(GuiSettingsId::CAMERA_TRACK_MEDIAN);
21  if (useMedian) {
22  const Vector offset = settings.get<Vector>(GuiSettingsId::CAMERA_TRACKING_OFFSET);
23  return makeAuto<MedianTracker>(offset);
24  }
25  return nullptr;
26 }
27 
28 AutoPtr<ICamera> Factory::getCamera(const GuiSettings& settings, const Pixel size) {
29  CameraEnum cameraId = settings.get<CameraEnum>(GuiSettingsId::CAMERA_TYPE);
30  CameraParams data;
31  data.imageSize = size;
32  data.position = settings.get<Vector>(GuiSettingsId::CAMERA_POSITION);
33  data.target = settings.get<Vector>(GuiSettingsId::CAMERA_TARGET);
34  data.up = settings.get<Vector>(GuiSettingsId::CAMERA_UP);
35  data.clipping = Interval(settings.get<Float>(GuiSettingsId::CAMERA_CLIP_NEAR),
36  settings.get<Float>(GuiSettingsId::CAMERA_CLIP_FAR));
37  data.perspective.fov = settings.get<Float>(GuiSettingsId::CAMERA_PERSPECTIVE_FOV);
38  data.ortho.fov = float(settings.get<Float>(GuiSettingsId::CAMERA_ORTHO_FOV));
39  data.ortho.cutoff = float(settings.get<Float>(GuiSettingsId::CAMERA_ORTHO_CUTOFF));
40  if (data.ortho.cutoff.value() == 0._f) {
41  data.ortho.cutoff = NOTHING;
42  }
43 
44  switch (cameraId) {
45  case CameraEnum::ORTHO:
46  return makeAuto<OrthoCamera>(data);
47  case CameraEnum::PERSPECTIVE:
48  return makeAuto<PerspectiveCamera>(data);
49  case CameraEnum::FISHEYE:
50  return makeAuto<FisheyeCamera>(data);
51  case CameraEnum::SPHERICAL:
52  return makeAuto<SphericalCamera>(data);
53  default:
54  NOT_IMPLEMENTED;
55  }
56 }
57 
58 AutoPtr<IRenderer> Factory::getRenderer(const GuiSettings& settings) {
59  SharedPtr<IScheduler> scheduler = getScheduler(RunSettings::getDefaults());
60  return getRenderer(scheduler, settings);
61 }
62 
63 AutoPtr<IRenderer> Factory::getRenderer(SharedPtr<IScheduler> scheduler, const GuiSettings& settings) {
64  RendererEnum id = settings.get<RendererEnum>(GuiSettingsId::RENDERER);
65  AutoPtr<IRenderer> renderer;
66  switch (id) {
67  case RendererEnum::NONE:
68  class NullRenderer : public IRenderer {
69  virtual void initialize(const Storage&, const IColorizer&, const ICamera&) override {}
70  virtual bool isInitialized() const override {
71  return true;
72  }
73  virtual void render(const RenderParams&, Statistics&, IRenderOutput&) const override {}
74  virtual void cancelRender() override {}
75  };
76  renderer = makeAuto<NullRenderer>();
77  break;
78  case RendererEnum::PARTICLE:
79  renderer = makeAuto<ParticleRenderer>(settings);
80  break;
81  case RendererEnum::MESH:
82  renderer = makeAuto<MeshRenderer>(scheduler, settings);
83  break;
84  case RendererEnum::RAYMARCHER:
85  renderer = makeAuto<RayMarcher>(scheduler, settings);
86  break;
87  case RendererEnum::VOLUME:
88  renderer = makeAuto<VolumeRenderer>(scheduler, settings);
89  break;
90  case RendererEnum::CONTOUR:
91  renderer = makeAuto<ContourRenderer>(scheduler, settings);
92  break;
93  default:
94  NOT_IMPLEMENTED;
95  }
96 
97  return renderer;
98 }
99 
100 AutoPtr<IBrdf> Factory::getBrdf(const GuiSettings& settings) {
101  const BrdfEnum id = settings.get<BrdfEnum>(GuiSettingsId::RAYTRACE_BRDF);
102  switch (id) {
103  case BrdfEnum::LAMBERT:
104  return makeAuto<LambertBrdf>(1._f);
105  case BrdfEnum::PHONG:
106  return makeAuto<PhongBrdf>(1._f);
107  default:
108  NOT_IMPLEMENTED;
109  }
110 }
111 
112 AutoPtr<IColorMap> Factory::getColorMap(const GuiSettings& settings) {
113  const ColorMapEnum id = settings.get<ColorMapEnum>(GuiSettingsId::COLORMAP_TYPE);
114  switch (id) {
115  case ColorMapEnum::LINEAR:
116  return nullptr;
117  case ColorMapEnum::LOGARITHMIC: {
118  const float factor = settings.get<Float>(GuiSettingsId::COLORMAP_LOGARITHMIC_FACTOR);
119  return makeAuto<LogarithmicColorMap>(factor);
120  }
121  case ColorMapEnum::FILMIC:
122  return makeAuto<FilmicColorMap>();
123  default:
124  NOT_IMPLEMENTED;
125  }
126 }
127 
128 static AutoPtr<IColorizer> getColorizer(const GuiSettings& settings, const ExtColorizerId id) {
129  using Factory::getPalette;
130 
131  switch (id) {
132  case ColorizerId::VELOCITY:
133  return makeAuto<VelocityColorizer>(getPalette(id));
134  case ColorizerId::ACCELERATION:
135  return makeAuto<AccelerationColorizer>(getPalette(id));
136  case ColorizerId::MOVEMENT_DIRECTION:
137  return makeAuto<DirectionColorizer>(Vector(0._f, 0._f, 1._f), getPalette(id));
138  case ColorizerId::COROTATING_VELOCITY:
139  return makeAuto<CorotatingVelocityColorizer>(getPalette(ColorizerId::VELOCITY));
140  case ColorizerId::DENSITY_PERTURBATION:
141  return makeAuto<DensityPerturbationColorizer>(getPalette(id));
142  case ColorizerId::SUMMED_DENSITY:
143  return makeAuto<SummedDensityColorizer>(RunSettings::getDefaults(), getPalette(QuantityId::DENSITY));
144  case ColorizerId::TOTAL_ENERGY:
145  return makeAuto<EnergyColorizer>(getPalette(id));
146  case ColorizerId::TEMPERATURE:
147  return makeAuto<TemperatureColorizer>();
148  case ColorizerId::TOTAL_STRESS:
149  return makeAuto<StressColorizer>(getPalette(id));
150  case ColorizerId::YIELD_REDUCTION:
151  return makeAuto<YieldReductionColorizer>(getPalette(id));
152  case ColorizerId::DAMAGE_ACTIVATION:
153  return makeAuto<DamageActivationColorizer>(getPalette(id));
154  case ColorizerId::RADIUS:
155  return makeAuto<RadiusColorizer>(getPalette(id));
156  case ColorizerId::BOUNDARY:
157  return makeAuto<BoundaryColorizer>(BoundaryColorizer::Detection::NEIGBOUR_THRESHOLD, 40);
158  case ColorizerId::UVW:
159  return makeAuto<UvwColorizer>();
160  case ColorizerId::PARTICLE_ID:
161  return makeAuto<ParticleIdColorizer>(settings);
162  case ColorizerId::COMPONENT_ID:
163  return makeAuto<ComponentIdColorizer>(
164  settings, Post::ComponentFlag::OVERLAP | Post::ComponentFlag::SORT_BY_MASS);
165  case ColorizerId::BOUND_COMPONENT_ID:
166  return makeAuto<ComponentIdColorizer>(
167  settings, Post::ComponentFlag::ESCAPE_VELOCITY | Post::ComponentFlag::SORT_BY_MASS);
168  case ColorizerId::AGGREGATE_ID:
169  return makeAuto<AggregateIdColorizer>(settings);
170  case ColorizerId::FLAG:
171  return makeAuto<IndexColorizer>(QuantityId::FLAG, settings);
172  case ColorizerId::MATERIAL_ID:
173  return makeAuto<MaterialColorizer>(settings);
174  case ColorizerId::BEAUTY:
175  return makeAuto<BeautyColorizer>();
176  default:
177  QuantityId quantity = QuantityId(id);
178  SPH_ASSERT(int(quantity) >= 0);
179 
180  Palette palette = getPalette(id);
181  switch (getMetadata(quantity).expectedType) {
182  case ValueEnum::INDEX:
183  return makeAuto<TypedColorizer<Size>>(quantity, std::move(palette));
184  case ValueEnum::SCALAR:
185  return makeAuto<TypedColorizer<Float>>(quantity, std::move(palette));
186  case ValueEnum::VECTOR:
187  return makeAuto<TypedColorizer<Vector>>(quantity, std::move(palette));
188  case ValueEnum::TRACELESS_TENSOR:
189  return makeAuto<TypedColorizer<TracelessTensor>>(quantity, std::move(palette));
190  case ValueEnum::SYMMETRIC_TENSOR:
191  return makeAuto<TypedColorizer<SymmetricTensor>>(quantity, std::move(palette));
192  default:
193  NOT_IMPLEMENTED;
194  }
195  }
196 }
197 
198 AutoPtr<IColorizer> Factory::getColorizer(const Project& project, const ExtColorizerId id) {
199  AutoPtr<IColorizer> colorizer = Sph::getColorizer(project.getGuiSettings(), id);
200  Optional<Palette> palette = colorizer->getPalette();
201  if (palette && project.getPalette(colorizer->name(), palette.value())) {
202  colorizer->setPalette(palette.value());
203  }
204  return colorizer;
205 }
206 
207 struct PaletteDesc {
208  Interval range;
209  PaletteScale scale;
210 };
211 
212 static FlatMap<ExtColorizerId, PaletteDesc> paletteDescs = {
213  { QuantityId::DENSITY, { Interval(2650._f, 2750._f), PaletteScale::LINEAR } },
214  { QuantityId::MASS, { Interval(1.e5_f, 1.e10_f), PaletteScale::LOGARITHMIC } },
215  { QuantityId::PRESSURE, { Interval(-1.e5_f, 1.e10_f), PaletteScale::HYBRID } },
216  { QuantityId::ENERGY, { Interval(1._f, 1.e6_f), PaletteScale::LOGARITHMIC } },
217  { QuantityId::DEVIATORIC_STRESS, { Interval(0._f, 1.e10_f), PaletteScale::LINEAR } },
218  { QuantityId::DAMAGE, { Interval(0._f, 1._f), PaletteScale::LINEAR } },
219  { QuantityId::VELOCITY_DIVERGENCE, { Interval(-0.1_f, 0.1_f), PaletteScale::LINEAR } },
220  { QuantityId::VELOCITY_GRADIENT, { Interval(0._f, 1.e-3_f), PaletteScale::LINEAR } },
221  { QuantityId::VELOCITY_LAPLACIAN, { Interval(0._f, 1.e-3_f), PaletteScale::LINEAR } },
222  { QuantityId::VELOCITY_GRADIENT_OF_DIVERGENCE, { Interval(0._f, 1.e-3_f), PaletteScale::LINEAR } },
223  { QuantityId::VELOCITY_ROTATION, { Interval(0._f, 4._f), PaletteScale::LINEAR } },
224  { QuantityId::SOUND_SPEED, { Interval(0._f, 5.e3_f), PaletteScale::LINEAR } },
225  { QuantityId::VIBRATIONAL_VELOCITY, { Interval(0._f, 5.e3_f), PaletteScale::LINEAR } },
226  { QuantityId::BULK_DENSITY, { Interval(2650._f, 2750._f), PaletteScale::LINEAR } },
227  { QuantityId::AV_ALPHA, { Interval(0.1_f, 1.5_f), PaletteScale::LINEAR } },
228  { QuantityId::AV_BALSARA, { Interval(0._f, 1._f), PaletteScale::LINEAR } },
229  { QuantityId::AV_STRESS, { Interval(0._f, 1.e8_f), PaletteScale::LINEAR } },
230  { QuantityId::ANGULAR_FREQUENCY, { Interval(0._f, 1.e-3_f), PaletteScale::LINEAR } },
231  { QuantityId::MOMENT_OF_INERTIA, { Interval(0._f, 1.e10_f), PaletteScale::LINEAR } },
232  { QuantityId::PHASE_ANGLE, { Interval(0._f, 10._f), PaletteScale::LINEAR } },
233  { QuantityId::STRAIN_RATE_CORRECTION_TENSOR, { Interval(0._f, 5._f), PaletteScale::LINEAR } },
234  { QuantityId::EPS_MIN, { Interval(0._f, 1._f), PaletteScale::LINEAR } },
235  { QuantityId::FRICTION, { Interval(0._f, 1._f), PaletteScale::LINEAR } },
236  { QuantityId::DELTASPH_DENSITY_GRADIENT, { Interval(0._f, 1._f), PaletteScale::LINEAR } },
237  { QuantityId::NEIGHBOUR_CNT, { Interval(50._f, 150._f), PaletteScale::LINEAR } },
238  { ColorizerId::VELOCITY, { Interval(0.1_f, 100._f), PaletteScale::LOGARITHMIC } },
239  { ColorizerId::ACCELERATION, { Interval(0.1_f, 100._f), PaletteScale::LOGARITHMIC } },
240  { ColorizerId::MOVEMENT_DIRECTION, { Interval(0._f, 2._f * PI), PaletteScale::LINEAR } },
241  { ColorizerId::RADIUS, { Interval(0._f, 1.e3_f), PaletteScale::LINEAR } },
242  { ColorizerId::TOTAL_ENERGY, { Interval(1.e6_f, 1.e10_f), PaletteScale::LOGARITHMIC } },
243  { ColorizerId::TEMPERATURE, { Interval(100._f, 1.e7_f), PaletteScale::LOGARITHMIC } },
244  { ColorizerId::DENSITY_PERTURBATION, { Interval(-1.e-6_f, 1.e-6_f), PaletteScale::LINEAR } },
245  { ColorizerId::DAMAGE_ACTIVATION, { Interval(2.e-4_f, 8.e-4_f), PaletteScale::LINEAR } },
246  { ColorizerId::YIELD_REDUCTION, { Interval(0._f, 1._f), PaletteScale::LINEAR } },
247  { ColorizerId::TOTAL_STRESS, { Interval(0._f, 1e6_f), PaletteScale::LINEAR } },
248 };
249 
250 static Palette getDefaultPalette(const Interval range) {
251  const float x0 = float(range.lower());
252  const float dx = float(range.size());
253  return Palette({ { x0, Rgba(0.f, 0.f, 0.6f) },
254  { x0 + 0.2f * dx, Rgba(0.1f, 0.1f, 0.1f) },
255  { x0 + 0.6f * dx, Rgba(0.9f, 0.9f, 0.9f) },
256  { x0 + 0.8f * dx, Rgba(1.f, 1.f, 0.f) },
257  { x0 + dx, Rgba(0.6f, 0.f, 0.f) } },
258  PaletteScale::LINEAR);
259 }
260 
261 Palette Factory::getPalette(const ExtColorizerId id) {
262  const PaletteDesc desc = paletteDescs[id];
263  const Interval range = desc.range;
264  const PaletteScale scale = desc.scale;
265  const float x0 = float(range.lower());
266  const float dx = float(range.size());
267  switch (id) {
268  case ColorizerId::VELOCITY:
269  return Palette({ { x0, Rgba(0.5f, 0.5f, 0.5f) },
270  { x0 + 0.001f * dx, Rgba(0.0f, 0.0f, 0.2f) },
271  { x0 + 0.01f * dx, Rgba(0.0f, 0.0f, 1.0f) },
272  { x0 + 0.1f * dx, Rgba(1.0f, 0.0f, 0.2f) },
273  { x0 + dx, Rgba(1.0f, 1.0f, 0.2f) } },
274  scale);
275  case ColorizerId::ACCELERATION:
276  return Palette({ { x0, Rgba(0.5f, 0.5f, 0.5f) },
277  { x0 + 0.001f * dx, Rgba(0.0f, 0.0f, 0.2f) },
278  { x0 + 0.01f * dx, Rgba(0.0f, 0.0f, 1.0f) },
279  { x0 + 0.1f * dx, Rgba(1.0f, 0.0f, 0.2f) },
280  { x0 + dx, Rgba(1.0f, 1.0f, 0.2f) } },
281  scale);
282  case ColorizerId::MOVEMENT_DIRECTION: {
283  SPH_ASSERT(range == Interval(0.f, 2._f * PI)); // in radians
284  const float pi = float(PI);
285  return Palette({ { 0.f, Rgba(0.1f, 0.1f, 1.f) },
286  { pi / 3.f, Rgba(1.f, 0.1f, 1.f) },
287  { 2.f * pi / 3.f, Rgba(1.f, 0.1f, 0.1f) },
288  { 3.f * pi / 3.f, Rgba(1.f, 1.f, 0.1f) },
289  { 4.f * pi / 3.f, Rgba(0.1f, 1.f, 0.1f) },
290  { 5.f * pi / 3.f, Rgba(0.1f, 1.f, 1.f) },
291  { 2.f * pi, Rgba(0.1f, 0.1f, 1.f) } },
292  scale);
293  }
294  case ColorizerId::DENSITY_PERTURBATION:
295  return Palette({ { x0, Rgba(0.1f, 0.1f, 1.f) },
296  { x0 + 0.5f * dx, Rgba(0.7f, 0.7f, 0.7f) },
297  { x0 + dx, Rgba(1.f, 0.1f, 0.1f) } },
298  scale);
299  case ColorizerId::TOTAL_ENERGY:
300  return Palette({ { x0, Rgba(0.f, 0.f, 0.6f) },
301  { x0 + 0.01f * dx, Rgba(0.1f, 0.1f, 0.1f) },
302  { x0 + 0.05f * dx, Rgba(0.9f, 0.9f, 0.9f) },
303  { x0 + 0.2f * dx, Rgba(1.f, 1.f, 0.f) },
304  { x0 + dx, Rgba(0.6f, 0.f, 0.f) } },
305  scale);
306  case ColorizerId::TEMPERATURE:
307  return Palette({ { x0, Rgba(0.1f, 0.1f, 0.1f) },
308  { x0 + 0.001f * dx, Rgba(0.1f, 0.1f, 1.f) },
309  { x0 + 0.01f * dx, Rgba(1.f, 0.f, 0.f) },
310  { x0 + 0.1f * dx, Rgba(1.0f, 0.6f, 0.4f) },
311  { x0 + dx, Rgba(1.f, 1.f, 0.f) } },
312  scale);
313  case ColorizerId::YIELD_REDUCTION:
314  return Palette({ { 0._f, Rgba(0.1f, 0.1f, 0.1f) }, { 1._f, Rgba(0.9f, 0.9f, 0.9f) } }, scale);
315  case ColorizerId::DAMAGE_ACTIVATION:
316  return Palette({ { x0, Rgba(0.1f, 0.1f, 1.f) },
317  { x0 + 0.5f * dx, Rgba(0.7f, 0.7f, 0.7f) },
318  { x0 + dx, Rgba(1.f, 0.1f, 0.1f) } },
319  scale);
320  case ColorizerId::RADIUS:
321  return Palette({ { x0, Rgba(0.1f, 0.1f, 1.f) },
322  { x0 + 0.5f * dx, Rgba(0.7f, 0.7f, 0.7f) },
323  { x0 + dx, Rgba(1.f, 0.1f, 0.1f) } },
324  scale);
325  default:
326  // check extended values
327  switch (QuantityId(id)) {
328  case QuantityId::PRESSURE:
329  SPH_ASSERT(x0 < -1.f);
330  return Palette({ { x0, Rgba(0.3f, 0.3f, 0.8f) },
331  { -1.e4f, Rgba(0.f, 0.f, 0.2f) },
332  { 0.f, Rgba(0.2f, 0.2f, 0.2f) },
333  { 1.e4f, Rgba(0.8f, 0.8f, 0.8f) },
334  { 2.e4f, Rgba(1.f, 1.f, 0.2f) },
335  { x0 + dx, Rgba(0.5f, 0.f, 0.f) } },
336  scale);
337  case QuantityId::ENERGY:
338  return Palette({ { x0, Rgba(0.1f, 0.1f, 0.1f) },
339  { x0 + 0.001f * dx, Rgba(0.1f, 0.1f, 1.f) },
340  { x0 + 0.01f * dx, Rgba(1.f, 0.f, 0.f) },
341  { x0 + 0.1f * dx, Rgba(1.0f, 0.6f, 0.4f) },
342  { x0 + dx, Rgba(1.f, 1.f, 0.f) } },
343  scale);
344  case QuantityId::DEVIATORIC_STRESS:
345  return Palette({ { x0, Rgba(0.f, 0.f, 0.2f) },
346  { x0 + 0.1f * dx, Rgba(0.9f, 0.9f, 0.9f) },
347  { x0 + 0.25f * dx, Rgba(1.f, 1.f, 0.2f) },
348  { x0 + 0.5f * dx, Rgba(1.f, 0.5f, 0.f) },
349  { x0 + dx, Rgba(0.5f, 0.f, 0.f) } },
350  scale);
351  case QuantityId::DENSITY:
352  case QuantityId::BULK_DENSITY:
353  case QuantityId::VELOCITY_LAPLACIAN:
354  case QuantityId::FRICTION:
355  case QuantityId::VELOCITY_GRADIENT_OF_DIVERGENCE:
356  return Palette({ { x0, Rgba(0.4f, 0.f, 0.4f) },
357  { x0 + 0.3f * dx, Rgba(0.3f, 0.3f, 1.f) },
358  { x0 + 0.5f * dx, Rgba(0.9f, 0.9f, 0.9f) },
359  { x0 + 0.7f * dx, Rgba(1.f, 0.f, 0.f) },
360  { x0 + dx, Rgba(1.f, 1.f, 0.f) } },
361  scale);
362  case QuantityId::DAMAGE:
363  return Palette({ { x0, Rgba(0.1f, 0.1f, 0.1f) }, { x0 + dx, Rgba(0.9f, 0.9f, 0.9f) } }, scale);
364  case QuantityId::MASS:
365  return Palette({ { x0, Rgba(0.1f, 0.1f, 0.1f) }, { x0 + dx, Rgba(0.9f, 0.9f, 0.9f) } }, scale);
366  case QuantityId::VELOCITY_DIVERGENCE:
367  SPH_ASSERT(x0 < 0._f);
368  return Palette({ { x0, Rgba(0.3f, 0.3f, 0.8f) },
369  { 0.1f * x0, Rgba(0.f, 0.f, 0.2f) },
370  { 0.f, Rgba(0.2f, 0.2f, 0.2f) },
371  { 0.1f * (x0 + dx), Rgba(0.8f, 0.8f, 0.8f) },
372  { x0 + dx, Rgba(1.0f, 0.6f, 0.f) } },
373  scale);
374  case QuantityId::VELOCITY_GRADIENT:
375  SPH_ASSERT(x0 == 0._f);
376  return Palette({ { 0._f, Rgba(0.3f, 0.3f, 0.8f) },
377  { 0.01f * dx, Rgba(0.f, 0.f, 0.2f) },
378  { 0.05f * dx, Rgba(0.2f, 0.2f, 0.2f) },
379  { 0.2f * dx, Rgba(0.8f, 0.8f, 0.8f) },
380  { dx, Rgba(1.0f, 0.6f, 0.f) } },
381  scale);
382  case QuantityId::ANGULAR_FREQUENCY:
383  SPH_ASSERT(x0 == 0._f);
384  return Palette({ { 0._f, Rgba(0.3f, 0.3f, 0.8f) },
385  { 0.25f * dx, Rgba(0.f, 0.f, 0.2f) },
386  { 0.5f * dx, Rgba(0.2f, 0.2f, 0.2f) },
387  { 0.75f * dx, Rgba(0.8f, 0.8f, 0.8f) },
388  { dx, Rgba(1.0f, 0.6f, 0.f) } },
389  scale);
390  case QuantityId::STRAIN_RATE_CORRECTION_TENSOR: {
391  // sqrt(3) is an important value, as it corresponds to identity tensor
392  const float actDx = max(dx, sqrt(3.f) + 0.2f);
393  const float eps = 0.05f;
394  return Palette({ { 0._f, Rgba(0.f, 0.0f, 0.5f) },
395  { sqrt(3.f) - eps, Rgba(0.9f, 0.9f, 0.9f) },
396  { sqrt(3.f), Rgba(1.f, 1.f, 0.f) },
397  { sqrt(3.f) + eps, Rgba(0.9f, 0.9f, 0.9f) },
398  { actDx, Rgba(0.5f, 0.0f, 0.0f) } },
399  scale);
400  }
401  case QuantityId::AV_BALSARA:
402  return Palette({ { x0, Rgba(0.1f, 0.1f, 0.1f) }, { x0 + dx, Rgba(0.9f, 0.9f, 0.9f) } }, scale);
403  case QuantityId::EPS_MIN:
404  return Palette({ { x0, Rgba(0.1f, 0.1f, 1.f) },
405  { x0 + 0.5f * dx, Rgba(0.7f, 0.7f, 0.7f) },
406  { x0 + dx, Rgba(1.f, 0.1f, 0.1f) } },
407  scale);
408  case QuantityId::MOMENT_OF_INERTIA:
409  return Palette({ { x0, Rgba(0.1f, 0.1f, 1.f) },
410  { x0 + 0.5f * dx, Rgba(0.7f, 0.7f, 0.7f) },
411  { x0 + dx, Rgba(1.f, 0.1f, 0.1f) } },
412  scale);
413  default:
414  return getDefaultPalette(Interval(x0, x0 + dx));
415  }
416  }
417 }
418 
419 NAMESPACE_SPH_END
SPH_ASSERT
#define SPH_ASSERT(x,...)
Definition: Assert.h:94
NOT_IMPLEMENTED
#define NOT_IMPLEMENTED
Helper macro marking missing implementation.
Definition: Assert.h:100
NAMESPACE_SPH_BEGIN
NAMESPACE_SPH_BEGIN
Definition: BarnesHut.cpp:13
Camera.h
Defines projection transforming 3D particles onto 2D screen.
Colorizer.h
Object converting quantity values of particles into colors.
ColorizerId::TOTAL_STRESS
@ TOTAL_STRESS
Total stress (sigma = S - pI)
ColorizerId::FLAG
@ FLAG
Particles of different bodies are colored differently.
ColorizerId::COROTATING_VELOCITY
@ COROTATING_VELOCITY
Velocities with a respect to the rotating body.
ColorizerId::MOVEMENT_DIRECTION
@ MOVEMENT_DIRECTION
Projected direction of motion.
ColorizerId::RADIUS
@ RADIUS
Radii/smoothing lenghts of particles.
ColorizerId::SUMMED_DENSITY
@ SUMMED_DENSITY
Density computed from particle masses by direct summation of neighbours.
ColorizerId::DENSITY_PERTURBATION
@ DENSITY_PERTURBATION
Relative difference of density and initial density (rho/rho0 - 1)
ColorizerId::COMPONENT_ID
@ COMPONENT_ID
Color assigned to each component (group of connected particles)
ColorizerId::VELOCITY
@ VELOCITY
Particle velocities.
ColorizerId::YIELD_REDUCTION
@ YIELD_REDUCTION
Reduction of stress tensor due to yielding (1 - f_vonMises)
ColorizerId::PARTICLE_ID
@ PARTICLE_ID
Each particle drawn with different color.
ColorizerId::TOTAL_ENERGY
@ TOTAL_ENERGY
Sum of kinetic and internal energy for given particle.
ColorizerId::BOUND_COMPONENT_ID
@ BOUND_COMPONENT_ID
Color assigned to each group of gravitationally bound particles.
ColorizerId::DAMAGE_ACTIVATION
@ DAMAGE_ACTIVATION
Ratio of the stress and the activation strain.
ColorizerId::BOUNDARY
@ BOUNDARY
Shows boundary particles.
ColorizerId::AGGREGATE_ID
@ AGGREGATE_ID
Color assigned to each aggregate.
ColorizerId::TEMPERATURE
@ TEMPERATURE
Temperature, computed from internal energy.
ColorizerId::ACCELERATION
@ ACCELERATION
Acceleration of particles.
ColorizerId::BEAUTY
@ BEAUTY
Attempts to show the real-world look.
ColorizerId::MATERIAL_ID
@ MATERIAL_ID
Particles with different materials are colored differently.
ColorizerId::UVW
@ UVW
Shows UV mapping, u-coordinate in red and v-coordinate in blur.
ContourRenderer.h
Renderer drawing iso-contours of specified quantity.
Float
double Float
Precision used withing the code. Use Float instead of float or double where precision is important.
Definition: Globals.h:13
max
constexpr INLINE T max(const T &f1, const T &f2)
Definition: MathBasic.h:20
sqrt
INLINE T sqrt(const T f)
Return a squared root of a value.
Definition: MathUtils.h:78
PI
constexpr Float PI
Mathematical constants.
Definition: MathUtils.h:361
MeshRenderer.h
Renderer visualizing the surface as triangle mesh.
NAMESPACE_SPH_END
#define NAMESPACE_SPH_END
Definition: Object.h:12
NOTHING
const NothingType NOTHING
Definition: Optional.h:16
PaletteScale
PaletteScale
Definition: Palette.h:13
PaletteScale::HYBRID
@ HYBRID
Logarithic scale for values > 1 and < -1, linear scale on interval <-1, 1>
PaletteScale::LINEAR
@ LINEAR
Control points are interpolated on linear scale.
PaletteScale::LOGARITHMIC
@ LOGARITHMIC
Control points are interpolated on logarithmic scale. All points must be positive!
ParticleRenderer.h
Renderer drawing individual particles as dots.
ValueEnum::SYMMETRIC_TENSOR
@ SYMMETRIC_TENSOR
ValueEnum::TRACELESS_TENSOR
@ TRACELESS_TENSOR
getMetadata
QuantityMetadata getMetadata(const QuantityId key)
Returns the quantity information using quantity ID.
Definition: QuantityIds.cpp:27
QuantityId
QuantityId
Unique IDs of basic quantities of SPH particles.
Definition: QuantityIds.h:19
QuantityId::BULK_DENSITY
@ BULK_DENSITY
Bulk density, may be lower than the material density.
QuantityId::AV_ALPHA
@ AV_ALPHA
Coefficient alpha of the artificial viscosity. Coefficient beta is always 2*alpha.
QuantityId::FLAG
@ FLAG
ID of original body, used to implement discontinuities between bodies in SPH.
QuantityId::VELOCITY_DIVERGENCE
@ VELOCITY_DIVERGENCE
Velocity divergence.
QuantityId::STRAIN_RATE_CORRECTION_TENSOR
@ STRAIN_RATE_CORRECTION_TENSOR
Correction tensor used to improve conservation of total angular momentum.
QuantityId::DEVIATORIC_STRESS
@ DEVIATORIC_STRESS
Deviatoric stress tensor, always a traceless tensor.
QuantityId::PRESSURE
@ PRESSURE
Pressure, affected by yielding and fragmentation model, always a scalar quantity.
QuantityId::AV_BALSARA
@ AV_BALSARA
Balsara factor.
QuantityId::MOMENT_OF_INERTIA
@ MOMENT_OF_INERTIA
Moment of inertia of particles, analogy of particle masses for rotation.
QuantityId::VELOCITY_GRADIENT
@ VELOCITY_GRADIENT
Velocity gradient.
QuantityId::DAMAGE
@ DAMAGE
Damage.
QuantityId::ENERGY
@ ENERGY
Specific internal energy, always a scalar quantity.
QuantityId::VELOCITY_LAPLACIAN
@ VELOCITY_LAPLACIAN
QuantityId::VELOCITY_ROTATION
@ VELOCITY_ROTATION
Velocity rotation.
QuantityId::DENSITY
@ DENSITY
Density, always a scalar quantity.
QuantityId::DELTASPH_DENSITY_GRADIENT
@ DELTASPH_DENSITY_GRADIENT
QuantityId::MASS
@ MASS
Paricles masses, always a scalar quantity.
QuantityId::NEIGHBOUR_CNT
@ NEIGHBOUR_CNT
Number of neighbouring particles (in radius h * kernel.radius)
QuantityId::SOUND_SPEED
@ SOUND_SPEED
Sound speed, always a scalar quantity.
QuantityId::AV_STRESS
@ AV_STRESS
Artificial stress by Monaghan .
QuantityId::VIBRATIONAL_VELOCITY
@ VIBRATIONAL_VELOCITY
Vibrational particle velocity, used by the block model of acoustic fluidization.
QuantityId::EPS_MIN
@ EPS_MIN
Activation strait rate.
QuantityId::VELOCITY_GRADIENT_OF_DIVERGENCE
@ VELOCITY_GRADIENT_OF_DIVERGENCE
Vector
BasicVector< Float > Vector
Definition: Vector.h:539
ExtendedEnum
Helper type allowing to "derive" from enum class.
Definition: ExtendedEnum.h:24
FlatMap
Container of key-value pairs.
Definition: FlatMap.h:19
GuiSettings::get
INLINE TValue get(const GuiSettingsId id) const
Definition: Settings.h:245
ICamera
Interface defining a camera or view, used by a renderer.
Definition: Camera.h:62
IColorizer
Interface for objects assigning colors to particles.
Definition: Colorizer.h:34
IColorizer::getPalette
virtual Optional< Palette > getPalette() const =0
Returns recommended palette for drawing this colorizer.
IColorizer::name
virtual std::string name() const =0
Returns the name of the colorizer.
IColorizer::setPalette
virtual void setPalette(const Palette &newPalette)=0
Modifies the palette used by ths colorizer.
IRenderer
Interface used to implement renderers.
Definition: IRenderer.h:166
IRenderer::initialize
virtual void initialize(const Storage &storage, const IColorizer &colorizer, const ICamera &camera)=0
Prepares the objects for rendering and updates its data.
IRenderer::render
virtual void render(const RenderParams &params, Statistics &stats, IRenderOutput &output) const =0
Draws particles into the bitmap, given the data provided in initialize.
IRenderer::cancelRender
virtual void cancelRender()=0
Stops the rendering if it is currently in progress.
IRenderer::isInitialized
virtual bool isInitialized() const =0
Checks if the renderer has been initialized.
Interval
Object representing a 1D interval of real numbers.
Definition: Interval.h:17
Interval::lower
INLINE Float lower() const
Returns lower bound of the interval.
Definition: Interval.h:74
Interval::size
INLINE Float size() const
Returns the size of the interval.
Definition: Interval.h:89
Optional::value
INLINE Type & value()
Returns the reference to the stored value.
Definition: Optional.h:172
Palette
Represents a color palette, used for mapping arbitrary number to a color.
Definition: Palette.h:25
Project::getPalette
bool getPalette(const std::string &name, Palette &palette) const
Definition: Project.h:41
Project::getGuiSettings
GuiSettings & getGuiSettings()
Definition: Project.h:51
Rgba
Definition: Color.h:8
Settings< RunSettingsId >::getDefaults
static const Settings & getDefaults()
\brief Returns a reference to object containing default values of all settings.
Definition: Settings.impl.h:357
Statistics
Object holding various statistics about current run.
Definition: Statistics.h:22
Storage
Container storing all quantities used within the simulations.
Definition: Storage.h:230
GuiSettingsId::COLORMAP_LOGARITHMIC_FACTOR
@ COLORMAP_LOGARITHMIC_FACTOR
GuiSettingsId::CAMERA_ORTHO_CUTOFF
@ CAMERA_ORTHO_CUTOFF
Max z-coordinate of particle to be displayed by ortho renderer.
GuiSettingsId::RENDERER
@ RENDERER
Selected renderer.
GuiSettingsId::CAMERA_ORTHO_FOV
@ CAMERA_ORTHO_FOV
View field of view (zoom). Special value 0 means the field of view is computed from the bounding box.
ColorMapEnum
ColorMapEnum
Definition: Settings.h:85
BrdfEnum
BrdfEnum
Definition: Settings.h:80
CameraEnum
CameraEnum
Definition: Settings.h:35
RendererEnum
RendererEnum
Definition: Settings.h:14
RendererEnum::PARTICLE
@ PARTICLE
2D section showing particles as points
RendererEnum::MESH
@ MESH
Surfaces of bodies are meshed using Marching cubes and drawed as triangles.
RendererEnum::RAYMARCHER
@ RAYMARCHER
Raymarcher that computes intersections with implicit surface.
RendererEnum::VOLUME
@ VOLUME
Volumetric renderer.
RendererEnum::CONTOUR
@ CONTOUR
Draws contours (iso-lines) of quantities.
RendererEnum::NONE
@ NONE
No particle visualization.
Factory::getColorMap
AutoPtr< IColorMap > getColorMap(const GuiSettings &settings)
Definition: Factory.cpp:112
Factory::getColorizer
AutoPtr< IColorizer > getColorizer(const Project &project, const ExtColorizerId id)
Definition: Factory.cpp:198
Factory::getTracker
AutoPtr< ITracker > getTracker(const GuiSettings &settings)
Definition: Factory.cpp:15
Factory::getBrdf
AutoPtr< IBrdf > getBrdf(const GuiSettings &settings)
Definition: Factory.cpp:100
Factory::getPalette
Palette getPalette(const ExtColorizerId id)
Definition: Factory.cpp:261
Factory::getRenderer
AutoPtr< IRenderer > getRenderer(const GuiSettings &settings)
Definition: Factory.cpp:58
Factory::getCamera
AutoPtr< ICamera > getCamera(const GuiSettings &settings, const Pixel size)
Definition: Factory.cpp:28
Factory::getScheduler
SharedPtr< IScheduler > getScheduler(const RunSettings &settings=RunSettings::getDefaults())
Definition: Factory.cpp:178
Post::ComponentFlag::OVERLAP
@ OVERLAP
Specifies that overlapping particles belong into the same component.
CameraParams::imageSize
Pixel imageSize
Size of the image.
Definition: Camera.h:136
PaletteDesc::scale
PaletteScale scale
Definition: Factory.cpp:209
PaletteDesc::range
Interval range
Definition: Factory.cpp:208
Pixel
Definition: Point.h:101
RenderParams
Parameters of the rendered image.
Definition: IRenderer.h:60
Generated by doxygen 1.9.1