sph/docs/CameraJobs_8cpp_source.html

 #include "gui/objects/CameraJobs.h"

 #include "gui/Factory.h"


 NAMESPACE_SPH_BEGIN


 void ICameraJob::evaluate(const RunSettings& UNUSED(global), IRunCallbacks& UNUSED(callbacks)) {

     const int width = gui.get<int>(GuiSettingsId::IMAGES_WIDTH);

     const int height = gui.get<int>(GuiSettingsId::IMAGES_HEIGHT);

     AutoPtr<ICamera> camera = Factory::getCamera(gui, Pixel(width, height));

     AutoPtr<ITracker> tracker = Factory::getTracker(gui);


     result = makeShared<CameraData>();

     result->camera = std::move(camera);

     result->tracker = std::move(tracker);

     result->overrides.set(GuiSettingsId::CAMERA_VELOCITY, gui.get<Vector>(GuiSettingsId::CAMERA_VELOCITY));

     result->overrides.set(GuiSettingsId::CAMERA_ORBIT, gui.get<Float>(GuiSettingsId::CAMERA_ORBIT));

 }


 // ----------------------------------------------------------------------------------------------------------

 // OrthoCameraJob

 // ----------------------------------------------------------------------------------------------------------


 OrthoCameraJob::OrthoCameraJob(const std::string& name)

     : ICameraJob(name) {

     gui.set(GuiSettingsId::CAMERA_TYPE, CameraEnum::ORTHO);

 }


 static VirtualSettings::Category& addResolutionCategory(VirtualSettings& connector, GuiSettings& gui) {

     VirtualSettings::Category& resCat = connector.addCategory("Resolution");

     resCat.connect<int>("Image width", gui, GuiSettingsId::IMAGES_WIDTH);

     resCat.connect<int>("Image height", gui, GuiSettingsId::IMAGES_HEIGHT);

     return resCat;

 }


 static VirtualSettings::Category& addTransformCategory(VirtualSettings& connector, GuiSettings& gui) {

     VirtualSettings::Category& transformCat = connector.addCategory("Transform");

     transformCat.connect<Vector>("Position [km]", gui, GuiSettingsId::CAMERA_POSITION).setUnits(1.e3_f);

     transformCat.connect<Vector>("Velocity [km/s]", gui, GuiSettingsId::CAMERA_VELOCITY)

         .setUnits(1.e3_f)

         .setEnabler([&gui] {

             return gui.get<int>(GuiSettingsId::CAMERA_TRACK_PARTICLE) == -1 &&

                    !gui.get<bool>(GuiSettingsId::CAMERA_TRACK_MEDIAN);

         });

     transformCat.connect<Float>("Orbit speed [s^-1]", gui, GuiSettingsId::CAMERA_ORBIT);

     transformCat.connect<Vector>("Target [km]", gui, GuiSettingsId::CAMERA_TARGET).setUnits(1.e3_f);

     transformCat.connect<Vector>("Up-direction", gui, GuiSettingsId::CAMERA_UP)

         .setValidator([](const IVirtualEntry::Value& value) {

             const Vector v = value.get<Vector>();

             return v != Vector(0._f);

         });

     transformCat.connect<Float>("Clip near [km]", gui, GuiSettingsId::CAMERA_CLIP_NEAR).setUnits(1.e3_f);

     transformCat.connect<Float>("Clip far [km]", gui, GuiSettingsId::CAMERA_CLIP_FAR).setUnits(1.e3_f);

     return transformCat;

 }


 static void addTrackingCategory(VirtualSettings& connector, GuiSettings& gui) {

     VirtualSettings::Category& trackingCat = connector.addCategory("Tracking");

     trackingCat.connect<int>("Track particle", gui, GuiSettingsId::CAMERA_TRACK_PARTICLE);

     trackingCat.connect<bool>("Track median", gui, GuiSettingsId::CAMERA_TRACK_MEDIAN).setEnabler([gui] {

         return gui.get<int>(GuiSettingsId::CAMERA_TRACK_PARTICLE) == -1;

     });

     trackingCat.connect<Vector>("Tracking offset", gui, GuiSettingsId::CAMERA_TRACKING_OFFSET)

         .setEnabler([gui] { return gui.get<bool>(GuiSettingsId::CAMERA_TRACK_MEDIAN); });

 }


 VirtualSettings OrthoCameraJob::getSettings() {

     VirtualSettings connector;

     addGenericCategory(connector, instName);

     addResolutionCategory(connector, gui);

     VirtualSettings::Category& transformCat = addTransformCategory(connector, gui);

     transformCat.connect<Float>("Ortho FoV [km]", gui, GuiSettingsId::CAMERA_ORTHO_FOV).setUnits(1.e3_f);

     transformCat.connect<Float>("Cutoff distance [km]", gui, GuiSettingsId::CAMERA_ORTHO_CUTOFF)

         .setUnits(1.e3_f);

     addTrackingCategory(connector, gui);

     return connector;

 }


 JobRegistrar sRegisterOrtho(

     "orthographic camera",

     "camera",

     "rendering",

     [](const std::string& name) { return makeAuto<OrthoCameraJob>(name); },

     "Creates an orthographic camera");


 // ----------------------------------------------------------------------------------------------------------

 // PerspectiveCameraJob

 // ----------------------------------------------------------------------------------------------------------


 PerspectiveCameraJob::PerspectiveCameraJob(const std::string& name)

     : ICameraJob(name) {

     gui.set(GuiSettingsId::CAMERA_TYPE, CameraEnum::PERSPECTIVE);

 }


 VirtualSettings PerspectiveCameraJob::getSettings() {

     VirtualSettings connector;

     addGenericCategory(connector, instName);

     addResolutionCategory(connector, gui);

     VirtualSettings::Category& transformCat = addTransformCategory(connector, gui);

     transformCat.connect<Float>("Field of view [deg]", gui, GuiSettingsId::CAMERA_PERSPECTIVE_FOV)

         .setUnits(DEG_TO_RAD);


     addTrackingCategory(connector, gui);


     return connector;

 }


 JobRegistrar sRegisterPerspective(

     "perspective camera",

     "camera",

     "rendering",

     [](const std::string& name) { return makeAuto<PerspectiveCameraJob>(name); },

     "Creates a perspective (pinhole) camera.");


 // ----------------------------------------------------------------------------------------------------------

 // FisheyeCameraJob

 // ----------------------------------------------------------------------------------------------------------


 FisheyeCameraJob::FisheyeCameraJob(const std::string& name)

     : ICameraJob(name) {

     gui.set(GuiSettingsId::CAMERA_TYPE, CameraEnum::FISHEYE);

 }


 VirtualSettings FisheyeCameraJob::getSettings() {

     VirtualSettings connector;

     addGenericCategory(connector, instName);

     addResolutionCategory(connector, gui);

     addTransformCategory(connector, gui);

     addTrackingCategory(connector, gui);

     return connector;

 }


 JobRegistrar sRegisterFisheye(

     "fisheye camera",

     "camera",

     "rendering",

     [](const std::string& name) { return makeAuto<FisheyeCameraJob>(name); },

     "Creates a fisheye camera.");


 NAMESPACE_SPH_END

NAMESPACE_SPH_BEGIN
NAMESPACE_SPH_BEGIN
Definition: BarnesHut.cpp:13

sRegisterOrtho
JobRegistrar sRegisterOrtho("orthographic camera", "camera", "rendering", [](const std::string &name) { return makeAuto< OrthoCameraJob >(name);}, "Creates an orthographic camera")

sRegisterPerspective
JobRegistrar sRegisterPerspective("perspective camera", "camera", "rendering", [](const std::string &name) { return makeAuto< PerspectiveCameraJob >(name);}, "Creates a perspective (pinhole) camera.")

sRegisterFisheye
JobRegistrar sRegisterFisheye("fisheye camera", "camera", "rendering", [](const std::string &name) { return makeAuto< FisheyeCameraJob >(name);}, "Creates a fisheye camera.")

CameraJobs.h

Float
double Float
Precision used withing the code. Use Float instead of float or double where precision is important.
Definition: Globals.h:13

addGenericCategory
VirtualSettings::Category & addGenericCategory(VirtualSettings &connector, std::string &instanceName)
Adds a common settings category, used by all jobs.
Definition: Job.cpp:43

DEG_TO_RAD
constexpr Float DEG_TO_RAD
Definition: MathUtils.h:369

UNUSED
#define UNUSED(x)
Definition: Object.h:37

NAMESPACE_SPH_END
#define NAMESPACE_SPH_END
Definition: Object.h:12

Vector
BasicVector< Float > Vector
Definition: Vector.h:539

AutoPtr< ICamera >

BasicVector< Float >

FisheyeCameraJob::getSettings
virtual VirtualSettings getSettings() override
Returns a settings object which allows to query and modify the state of the job.
Definition: CameraJobs.cpp:123

FisheyeCameraJob::FisheyeCameraJob
FisheyeCameraJob(const std::string &name)
Definition: CameraJobs.cpp:118

GuiSettings
Definition: Settings.h:238

GuiSettings::get
INLINE TValue get(const GuiSettingsId id) const
Definition: Settings.h:245

GuiSettings::set
INLINE GuiSettings & set(const GuiSettingsId id, const TValue &value)
Definition: Settings.h:250

ICameraJob
Definition: CameraJobs.h:22

ICameraJob::gui
GuiSettings gui
Definition: CameraJobs.h:27

ICameraJob::evaluate
virtual void evaluate(const RunSettings &global, IRunCallbacks &callbacks) override
Runs the operation provided by the job.
Definition: CameraJobs.cpp:6

IJob::instName
std::string instName
Definition: Job.h:100

IRunCallbacks
Callbacks executed by the simulation to provide feedback to the user.
Definition: IRun.h:27

OrthoCameraJob::OrthoCameraJob
OrthoCameraJob(const std::string &name)
Definition: CameraJobs.cpp:23

OrthoCameraJob::getSettings
virtual VirtualSettings getSettings() override
Returns a settings object which allows to query and modify the state of the job.
Definition: CameraJobs.cpp:66

PerspectiveCameraJob::PerspectiveCameraJob
PerspectiveCameraJob(const std::string &name)
Definition: CameraJobs.cpp:89

PerspectiveCameraJob::getSettings
virtual VirtualSettings getSettings() override
Returns a settings object which allows to query and modify the state of the job.
Definition: CameraJobs.cpp:94

Settings< RunSettingsId >

Variant
Variant, an implementation of type-safe union, similar to std::variant or boost::variant.
Definition: Variant.h:171

Variant::get
INLINE T & get()
Returns the stored value.
Definition: Variant.h:335

VirtualSettings::Category
Definition: VirtualSettings.h:231

VirtualSettings::Category::connect
EntryControl & connect(const std::string &name, const std::string &key, TValue &value)
Connects to given reference.
Definition: VirtualSettings.inl.h:114

VirtualSettings
Holds a map of virtual entries, associated with a unique name.
Definition: VirtualSettings.h:229

VirtualSettings::addCategory
Category & addCategory(const std::string &name)
Creates a new category of entries.
Definition: VirtualSettings.cpp:100

Factory.h

GuiSettingsId::CAMERA_TRACK_PARTICLE
@ CAMERA_TRACK_PARTICLE

GuiSettingsId::CAMERA_PERSPECTIVE_FOV
@ CAMERA_PERSPECTIVE_FOV

GuiSettingsId::CAMERA_POSITION
@ CAMERA_POSITION

GuiSettingsId::CAMERA_TRACKING_OFFSET
@ CAMERA_TRACKING_OFFSET

GuiSettingsId::IMAGES_HEIGHT
@ IMAGES_HEIGHT

GuiSettingsId::CAMERA_ORTHO_CUTOFF
@ CAMERA_ORTHO_CUTOFF
Max z-coordinate of particle to be displayed by ortho renderer.

GuiSettingsId::CAMERA_TARGET
@ CAMERA_TARGET

GuiSettingsId::CAMERA_CLIP_NEAR
@ CAMERA_CLIP_NEAR

GuiSettingsId::IMAGES_WIDTH
@ IMAGES_WIDTH

GuiSettingsId::CAMERA_TYPE
@ CAMERA_TYPE

GuiSettingsId::CAMERA_CLIP_FAR
@ CAMERA_CLIP_FAR

GuiSettingsId::CAMERA_VELOCITY
@ CAMERA_VELOCITY

GuiSettingsId::CAMERA_TRACK_MEDIAN
@ CAMERA_TRACK_MEDIAN

GuiSettingsId::CAMERA_UP
@ CAMERA_UP

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.

GuiSettingsId::CAMERA_ORBIT
@ CAMERA_ORBIT

CameraEnum::FISHEYE
@ FISHEYE

CameraEnum::ORTHO
@ ORTHO

CameraEnum::PERSPECTIVE
@ PERSPECTIVE

Factory::getTracker
AutoPtr< ITracker > getTracker(const GuiSettings &settings)
Definition: Factory.cpp:15

Factory::getCamera
AutoPtr< ICamera > getCamera(const GuiSettings &settings, const Pixel size)
Definition: Factory.cpp:28

CameraData::overrides
GuiSettings overrides
Definition: CameraJobs.h:19

CameraData::tracker
AutoPtr< ITracker > tracker
Definition: CameraJobs.h:17

CameraData::camera
AutoPtr< ICamera > camera
Definition: CameraJobs.h:16

JobRegistrar
Helper class, allowing to register job into the global list of jobs.
Definition: Job.h:203

Pixel
Definition: Point.h:101