components/operators/include/ftl/operators/antialiasing.hpp

@@ -12,7 +12,7 @@ namespace operators {
  */
 class FXAA : public ftl::operators::Operator {
 	public:
-    explicit FXAA(ftl::Configurable*);
+    explicit FXAA(ftl::operators::Graph *g, ftl::Configurable*);
     ~FXAA();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/buffer.hpp

+#ifndef _FTL_OPERATORS_BUFFERS_HPP_
+#define _FTL_OPERATORS_BUFFERS_HPP_
+
+namespace ftl {
+namespace operators {
+
+/**
+ * Similar to frame channels, but these are pipeline buffers that can be
+ * used from one operator to the next.
+ */
+enum class Buffer {
+	LowLeft			= 0,	// 8UC4
+	Screen			= 1,
+	Weights			= 2,	// short
+	Confidence		= 3,	// 32F
+	Contribution	= 4,	// 32F
+	Flow			= 5,	// 16SC2
+	Flow2			= 6,	// 16SC2
+	Energy			= 7,	// 32F
+	Mask			= 8,	// 32U
+	Density			= 9,	// 32F
+	Support1		= 10,	// 8UC4 (currently)
+	Support2		= 11,	// 8UC4 (currently)
+	Segmentation	= 12,	// 32S?	
+	Disparity		= 13,
+	Smoothing		= 14,	// 32F
+	LowGrayLeft		= 15,
+	LowGrayRight	= 16,
+	GrayLeft		= 17,
+	GrayRight		= 18,
+	LowRight		= 19
+};
+
+}
+}
+
+#endif
\ No newline at end of file

components/operators/include/ftl/operators/clipping.hpp

@@ -12,7 +12,7 @@ namespace operators {
  */
 class ClipScene : public ftl::operators::Operator {
 	public:
-    explicit ClipScene(ftl::Configurable*);
+    explicit ClipScene(ftl::operators::Graph *g, ftl::Configurable*);
     ~ClipScene();
 
 	inline Operator::Type type() const override { return Operator::Type::ManyToMany; }

components/operators/include/ftl/operators/colours.hpp

@@ -8,7 +8,7 @@ namespace operators {
 
 class ColourChannels : public ftl::operators::Operator {
     public:
-    explicit ColourChannels(ftl::Configurable *cfg);
+    explicit ColourChannels(ftl::operators::Graph *g, ftl::Configurable *cfg);
     ~ColourChannels();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/cuda/mask.hpp

@@ -83,6 +83,11 @@ void cull_mask(
 		unsigned int radius,
 		cudaStream_t stream);
 
+void show_mask(
+        ftl::cuda::TextureObject<uchar4> &colour,
+		ftl::cuda::TextureObject<uint8_t> &mask,
+        int id, uchar4 style, cudaStream_t stream);
+
 }
 }
 

components/operators/include/ftl/operators/depth.hpp

@@ -10,8 +10,8 @@ namespace operators {
 
 class DepthBilateralFilter : public::ftl::operators::Operator {
 	public:
-	explicit DepthBilateralFilter(ftl::Configurable*);
-	DepthBilateralFilter(ftl::Configurable*, const std::tuple<ftl::codecs::Channel> &);
+	explicit DepthBilateralFilter(ftl::operators::Graph *g, ftl::Configurable*);
+	DepthBilateralFilter(ftl::operators::Graph *g, ftl::Configurable*, const std::tuple<ftl::codecs::Channel> &);
 
 	~DepthBilateralFilter() {};
 

components/operators/include/ftl/operators/detectandtrack.hpp

@@ -39,7 +39,7 @@ namespace operators {
  */
 class DetectAndTrack : public ftl::operators::Operator {
 	public:
-	explicit DetectAndTrack(ftl::Configurable*);
+	explicit DetectAndTrack(ftl::operators::Graph *g, ftl::Configurable*);
 	~DetectAndTrack() {};
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -116,22 +116,21 @@ class DetectAndTrack : public ftl::operators::Operator {
  */
 class ArUco : public ftl::operators::Operator {
 	public:
-	explicit ArUco(ftl::Configurable*);
+	explicit ArUco(ftl::operators::Graph *g, ftl::Configurable*);
 	~ArUco() {};
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
 	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, cudaStream_t stream) override;
-
-	void wait(cudaStream_t) override;
+	virtual void wait(cudaStream_t) override;
 
 	ftl::codecs::Channel channel_in_;
 	ftl::codecs::Channel channel_out_;
 
 	private:
-	std::future<bool> job_;
-	bool debug_;
 	bool estimate_pose_;
 	float marker_size_;
+	cv::Mat tmp_;
+	std::future<void> job_;
 
 	cv::Ptr<cv::aruco::Dictionary> dictionary_;
 	cv::Ptr<cv::aruco::DetectorParameters> params_;

components/operators/include/ftl/operators/disparity.hpp

@@ -8,6 +8,7 @@
 #endif
 
 #include <opencv2/cudastereo.hpp>
+#include <opencv2/cudafilters.hpp>
 
 #ifdef HAVE_LIBSGM
 #include <libsgm.h>
@@ -19,7 +20,7 @@ namespace operators {
 
 class StereoDisparity : public ftl::operators::Operator {
 public:
-	explicit StereoDisparity(ftl::Configurable* cfg);
+	StereoDisparity(ftl::operators::Graph *g, ftl::Configurable* cfg);
 
 	~StereoDisparity();
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -44,7 +45,7 @@ private:
  */
 class FixstarsSGM : public ftl::operators::Operator {
 	public:
-	explicit FixstarsSGM(ftl::Configurable* cfg);
+	FixstarsSGM(ftl::operators::Graph *g, ftl::Configurable* cfg);
 
 	~FixstarsSGM();
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -57,11 +58,14 @@ class FixstarsSGM : public ftl::operators::Operator {
 	bool updateParameters();
 	bool updateP2Parameters();
 	void computeP2(cudaStream_t &stream);
+	void _variance_mask(cv::InputArray in, cv::OutputArray out, int wsize, cv::cuda::Stream &cvstream);
 
 	sgm::StereoSGM *ssgm_;
 	cv::Size size_;
 	cv::cuda::GpuMat lbw_;
 	cv::cuda::GpuMat rbw_;
+	cv::cuda::GpuMat lbw_full_;
+	cv::cuda::GpuMat rbw_full_;
 	cv::cuda::GpuMat disp_int_;
 
 	cv::cuda::GpuMat P2_map_;
@@ -69,6 +73,12 @@ class FixstarsSGM : public ftl::operators::Operator {
 	cv::cuda::GpuMat weightsF_;
 	cv::cuda::GpuMat edges_;
 	cv::Ptr<cv::cuda::CannyEdgeDetector> canny_;
+	cv::Ptr<cv::cuda::Filter> filter_;
+
+	cv::cuda::GpuMat im_;
+	cv::cuda::GpuMat im2_;
+	cv::cuda::GpuMat mean_;
+	cv::cuda::GpuMat mean2_;
 
 	int P1_;
 	int P2_;
@@ -80,7 +90,7 @@ class FixstarsSGM : public ftl::operators::Operator {
 
 class DisparityBilateralFilter : public::ftl::operators::Operator {
 	public:
-	explicit DisparityBilateralFilter(ftl::Configurable*);
+	DisparityBilateralFilter(ftl::operators::Graph *g, ftl::Configurable*);
 
 	~DisparityBilateralFilter() {};
 
@@ -91,6 +101,7 @@ class DisparityBilateralFilter : public::ftl::operators::Operator {
 	cv::Ptr<cv::cuda::DisparityBilateralFilter> filter_;
 	cv::cuda::GpuMat disp_int_;
 	cv::cuda::GpuMat disp_int_result_;
+	cv::cuda::GpuMat rgb_;
 	double scale_;
 	int radius_;
 	int iter_;
@@ -102,8 +113,8 @@ class DisparityBilateralFilter : public::ftl::operators::Operator {
  */
 class DisparityToDepth : public ftl::operators::Operator {
 	public:
-	explicit DisparityToDepth(ftl::Configurable* cfg) :
-		ftl::operators::Operator(cfg) {}
+	DisparityToDepth(ftl::operators::Graph *g, ftl::Configurable* cfg) :
+		ftl::operators::Operator(g, cfg) {}
 
 	~DisparityToDepth() {};
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -117,7 +128,7 @@ class DisparityToDepth : public ftl::operators::Operator {
  */
 class DepthChannel : public ftl::operators::Operator {
 	public:
-	explicit DepthChannel(ftl::Configurable *cfg);
+	DepthChannel(ftl::operators::Graph *g, ftl::Configurable *cfg);
 	~DepthChannel();
 
 	inline Operator::Type type() const override { return Operator::Type::ManyToMany; }
@@ -139,8 +150,8 @@ class DepthChannel : public ftl::operators::Operator {
 #ifdef HAVE_OPTFLOW
 class OpticalFlowTemporalSmoothing : public ftl::operators::Operator {
 	public:
-	explicit OpticalFlowTemporalSmoothing(ftl::Configurable*);
-	OpticalFlowTemporalSmoothing(ftl::Configurable*, const std::tuple<ftl::codecs::Channel> &params);
+	OpticalFlowTemporalSmoothing(ftl::operators::Graph *g, ftl::Configurable*);
+	OpticalFlowTemporalSmoothing(ftl::operators::Graph *g, ftl::Configurable*, const std::tuple<ftl::codecs::Channel> &params);
 	~OpticalFlowTemporalSmoothing();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/filling.hpp

@@ -12,7 +12,7 @@ namespace operators {
  */
 class ScanFieldFill : public ftl::operators::Operator {
 	public:
-    explicit ScanFieldFill(ftl::Configurable*);
+    ScanFieldFill(ftl::operators::Graph *g, ftl::Configurable*);
     ~ScanFieldFill();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -23,7 +23,7 @@ class ScanFieldFill : public ftl::operators::Operator {
 
 class CrossSupportFill : public ftl::operators::Operator {
 	public:
-    explicit CrossSupportFill(ftl::Configurable*);
+    CrossSupportFill(ftl::operators::Graph *g, ftl::Configurable*);
     ~CrossSupportFill();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/gt_analysis.hpp

@@ -14,7 +14,7 @@ namespace operators {
  */
 class GTAnalysis : public ftl::operators::Operator {
 	public:
-    explicit GTAnalysis(ftl::Configurable*);
+    GTAnalysis(ftl::operators::Graph *g, ftl::Configurable*);
     ~GTAnalysis();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/mask.hpp

@@ -14,7 +14,7 @@ namespace operators {
  */
 class DiscontinuityMask : public ftl::operators::Operator {
 	public:
-	explicit DiscontinuityMask(ftl::Configurable*);
+	DiscontinuityMask(ftl::operators::Graph *g, ftl::Configurable*);
 	~DiscontinuityMask();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -28,7 +28,7 @@ class DiscontinuityMask : public ftl::operators::Operator {
  */
 class BorderMask : public ftl::operators::Operator {
 	public:
-	explicit BorderMask(ftl::Configurable*);
+	BorderMask(ftl::operators::Graph *g, ftl::Configurable*);
 	~BorderMask();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -37,12 +37,26 @@ class BorderMask : public ftl::operators::Operator {
 
 };
 
+/**
+ * Visualise a mask value
+ */
+class DisplayMask : public ftl::operators::Operator {
+	public:
+	DisplayMask(ftl::operators::Graph *g, ftl::Configurable*);
+	~DisplayMask();
+
+	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
+
+	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, cudaStream_t stream) override;
+
+};
+
 /**
  * Remove depth values marked with the discontinuity mask.
  */
 class CullDiscontinuity : public ftl::operators::Operator {
 	public:
-	explicit CullDiscontinuity(ftl::Configurable*);
+	CullDiscontinuity(ftl::operators::Graph *g, ftl::Configurable*);
 	~CullDiscontinuity();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/mvmls.hpp

@@ -8,7 +8,7 @@ namespace operators {
 
 class MultiViewMLS : public ftl::operators::Operator {
 	public:
-	explicit MultiViewMLS(ftl::Configurable*);
+	MultiViewMLS(ftl::operators::Graph *g, ftl::Configurable*);
 	~MultiViewMLS();
 
 	inline Operator::Type type() const override { return Operator::Type::ManyToMany; }

components/operators/include/ftl/operators/normals.hpp

@@ -12,7 +12,7 @@ namespace operators {
  */
 class Normals : public ftl::operators::Operator {
 	public:
-    explicit Normals(ftl::Configurable*);
+    Normals(ftl::operators::Graph *g, ftl::Configurable*);
     ~Normals();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -29,7 +29,7 @@ class Normals : public ftl::operators::Operator {
  */
 class NormalDot : public ftl::operators::Operator {
 	public:
-    explicit NormalDot(ftl::Configurable*);
+    NormalDot(ftl::operators::Graph *g, ftl::Configurable*);
     ~NormalDot();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -44,7 +44,7 @@ class NormalDot : public ftl::operators::Operator {
  */
 class SmoothNormals : public ftl::operators::Operator {
 	public:
-    explicit SmoothNormals(ftl::Configurable*);
+    SmoothNormals(ftl::operators::Graph *g, ftl::Configurable*);
     ~SmoothNormals();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/operator.hpp

@@ -8,10 +8,13 @@
 #include <ftl/rgbd/frameset.hpp>
 #include <ftl/rgbd/source.hpp>
 #include <ftl/cuda_common.hpp>
+#include <ftl/operators/buffer.hpp>
 
 namespace ftl {
 namespace operators {
 
+class Graph;
+
 /**
  * An abstract frame operator interface. Any kind of filter that operates on a
  * single frame should use this as a base class. An example of a filter would
@@ -22,7 +25,7 @@ namespace operators {
  */
 class Operator {
 	public:
-	explicit Operator(ftl::Configurable *cfg);
+	Operator(Graph *pgraph, ftl::Configurable *cfg);
 	virtual ~Operator();
 
 	enum class Type {
@@ -58,9 +61,12 @@ class Operator {
 
 	inline ftl::Configurable *config() const { return config_; }
 
+	inline Graph *graph() const { return graph_; }
+
 	private:
 	bool enabled_;
 	ftl::Configurable *config_;
+	Graph *graph_;
 };
 
 namespace detail {
@@ -68,7 +74,7 @@ namespace detail {
 struct ConstructionHelperBase {
 	explicit ConstructionHelperBase(ftl::Configurable *cfg) : config(cfg) {}
 	virtual ~ConstructionHelperBase() {}
-	virtual ftl::operators::Operator *make()=0;
+	virtual ftl::operators::Operator *make(Graph *g)=0;
 
 	ftl::Configurable *config;
 };
@@ -77,8 +83,8 @@ template <typename T>
 struct ConstructionHelper : public ConstructionHelperBase {
 	explicit ConstructionHelper(ftl::Configurable *cfg) : ConstructionHelperBase(cfg) {}
 	~ConstructionHelper() {}
-	ftl::operators::Operator *make() override {
-		return new T(config);
+	ftl::operators::Operator *make(Graph *g) override {
+		return new T(g, config);
 	}
 };
 
@@ -88,8 +94,8 @@ struct ConstructionHelper2 : public ConstructionHelperBase {
 		arguments_ = std::make_tuple(args...);
 	}
 	~ConstructionHelper2() {}
-	ftl::operators::Operator *make() override {
-		return new T(config, arguments_);
+	ftl::operators::Operator *make(Graph *g) override {
+		return new T(g, config, arguments_);
 	}
 
 	private:
@@ -119,11 +125,12 @@ class Graph : public ftl::Configurable {
 	template <typename T, typename... ARGS>
 	ftl::Configurable *append(const std::string &name, ARGS...);
 
-	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, cudaStream_t stream=0);
-	bool apply(ftl::rgbd::FrameSet &in, ftl::rgbd::FrameSet &out, cudaStream_t stream=0);
-	bool apply(ftl::rgbd::FrameSet &in, ftl::rgbd::Frame &out, cudaStream_t stream=0);
+	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, const std::function<void()> &cb=nullptr);
+
+	bool queue(const ftl::data::FrameSetPtr &fs, const std::function<void()> &cb);
 
-	cudaStream_t getStream() const { return stream_; }
+	bool apply(ftl::rgbd::FrameSet &in, ftl::rgbd::FrameSet &out);
+	//bool apply(ftl::rgbd::FrameSet &in, ftl::rgbd::Frame &out, const std::function<void()> &cb=nullptr);
 
 	/**
 	 * Make sure all async operators have also completed. This is automatically
@@ -134,12 +141,26 @@ class Graph : public ftl::Configurable {
 	 */
 	bool waitAll(cudaStream_t);
 
+	inline cv::cuda::GpuMat &createBuffer(ftl::operators::Buffer b) { return createBuffer(b, 0); }
+	cv::cuda::GpuMat &createBuffer(ftl::operators::Buffer b, uint32_t fid);
+
+	cv::cuda::GpuMat &getBuffer(ftl::operators::Buffer b, uint32_t fid);
+
+	bool hasBuffer(ftl::operators::Buffer b, uint32_t fid) const;
+
 	private:
 	std::list<ftl::operators::detail::OperatorNode> operators_;
 	std::map<std::string, ftl::Configurable*> configs_;
-	cudaStream_t stream_;
+	std::atomic_flag busy_;
+	std::unordered_map<uint32_t,cv::cuda::GpuMat> buffers_;
+	std::unordered_set<uint32_t> valid_buffers_;
+	std::function<void()> callback_;
+	std::list<std::pair<ftl::data::FrameSetPtr, std::function<void()>>> queue_;
+	MUTEX mtx_;
 
 	ftl::Configurable *_append(ftl::operators::detail::ConstructionHelperBase*);
+	void _processOne();
+	bool _apply(ftl::rgbd::FrameSet &in, ftl::rgbd::FrameSet &out);
 };
 
 }

components/operators/include/ftl/operators/opticalflow.hpp

@@ -12,8 +12,8 @@ namespace operators {
  */
 class NVOpticalFlow : public ftl::operators::Operator {
 	public:
-	explicit NVOpticalFlow(ftl::Configurable*);
-	NVOpticalFlow(ftl::Configurable*, const std::tuple<ftl::codecs::Channel,ftl::codecs::Channel,ftl::codecs::Channel,ftl::codecs::Channel> &channels);
+	NVOpticalFlow(ftl::operators::Graph *g, ftl::Configurable*);
+	NVOpticalFlow(ftl::operators::Graph *g, ftl::Configurable*, const std::tuple<ftl::codecs::Channel,ftl::codecs::Channel,ftl::codecs::Channel,ftl::codecs::Channel> &channels);
 	~NVOpticalFlow();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/poser.hpp

@@ -15,26 +15,31 @@ namespace operators {
  */
 class Poser : public ftl::operators::Operator {
 	public:
-	explicit Poser(ftl::Configurable*);
+	Poser(ftl::operators::Graph *g, ftl::Configurable*);
 	~Poser();
 
 	inline Operator::Type type() const override { return Operator::Type::ManyToMany; }
 
 	bool apply(ftl::rgbd::FrameSet &in, ftl::rgbd::FrameSet &out, cudaStream_t stream) override;
 
+	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, cudaStream_t stream) override;
+
 	static bool get(const std::string &name, Eigen::Matrix4d &pose);
-	static bool set(const std::string &name, const Eigen::Matrix4d &pose);
+	static bool get(const std::string &name, ftl::codecs::Shape3D &shape);
+	static std::list<ftl::codecs::Shape3D*> getAll(int32_t fsid);
+
+	//static bool set(const ftl::codecs::Shape3D &shape);
+
+	static void add(const ftl::codecs::Shape3D &t, ftl::data::FrameID id);
 
     private:
 	struct PoseState {
-		Eigen::Matrix4d pose;
+		ftl::codecs::Shape3D shape;
 		bool locked;
 	};
 
     static std::unordered_map<std::string,PoseState> pose_db__;
-
-	void add(const ftl::codecs::Shape3D &t, int frameset, int frame);
-
+	static std::unordered_map<int,std::list<ftl::codecs::Shape3D*>> fs_shapes__;
 };
 
 }

components/operators/include/ftl/operators/segmentation.hpp

@@ -11,7 +11,7 @@ namespace operators {
  */
 class CrossSupport : public ftl::operators::Operator {
 	public:
-    explicit CrossSupport(ftl::Configurable*);
+    CrossSupport(ftl::operators::Graph *g, ftl::Configurable*);
     ~CrossSupport();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -25,7 +25,7 @@ class CrossSupport : public ftl::operators::Operator {
  */
 class VisCrossSupport : public ftl::operators::Operator {
 	public:
-    explicit VisCrossSupport(ftl::Configurable*);
+    VisCrossSupport(ftl::operators::Graph *g, ftl::Configurable*);
     ~VisCrossSupport();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/include/ftl/operators/smoothing.hpp

@@ -14,7 +14,7 @@ namespace operators {
  */
 class HFSmoother : public ftl::operators::Operator {
 	public:
-	explicit HFSmoother(ftl::Configurable*);
+	HFSmoother(ftl::operators::Graph *g, ftl::Configurable*);
 	~HFSmoother();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -23,7 +23,7 @@ class HFSmoother : public ftl::operators::Operator {
 
 	private:
 	cv::cuda::GpuMat temp_;
-	ftl::rgbd::Frame frames_[4];
+	//ftl::rgbd::Frame frames_[4];
 };
 
 /**
@@ -35,7 +35,7 @@ class HFSmoother : public ftl::operators::Operator {
  */
 class SmoothChannel : public ftl::operators::Operator {
 	public:
-	explicit SmoothChannel(ftl::Configurable*);
+	SmoothChannel(ftl::operators::Graph *g, ftl::Configurable*);
 	~SmoothChannel();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -43,7 +43,7 @@ class SmoothChannel : public ftl::operators::Operator {
 	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, cudaStream_t stream) override;
 
 	private:
-	ftl::rgbd::Frame temp_[6];
+	ftl::cuda::TextureObject<uchar4> temp_[6];
 };
 
 /**
@@ -53,7 +53,7 @@ class SmoothChannel : public ftl::operators::Operator {
  */
 class SimpleMLS : public ftl::operators::Operator {
 	public:
-	explicit SimpleMLS(ftl::Configurable*);
+	SimpleMLS(ftl::operators::Graph *g, ftl::Configurable*);
 	~SimpleMLS();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -61,7 +61,7 @@ class SimpleMLS : public ftl::operators::Operator {
 	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, cudaStream_t stream) override;
 
 	private:
-	ftl::rgbd::Frame temp_;
+	ftl::data::Frame temp_;
 };
 
 /**
@@ -70,7 +70,7 @@ class SimpleMLS : public ftl::operators::Operator {
  */
 class ColourMLS : public ftl::operators::Operator {
 	public:
-	explicit ColourMLS(ftl::Configurable*);
+	ColourMLS(ftl::operators::Graph *g, ftl::Configurable*);
 	~ColourMLS();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -78,7 +78,7 @@ class ColourMLS : public ftl::operators::Operator {
 	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, cudaStream_t stream) override;
 
 	private:
-	ftl::rgbd::Frame temp_;
+	ftl::data::Frame temp_;
 };
 
 /**
@@ -113,7 +113,7 @@ class ColourMLS : public ftl::operators::Operator {
  */
 class AggreMLS : public ftl::operators::Operator {
 	public:
-	explicit AggreMLS(ftl::Configurable*);
+	AggreMLS(ftl::operators::Graph *g, ftl::Configurable*);
 	~AggreMLS();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -125,7 +125,7 @@ class AggreMLS : public ftl::operators::Operator {
 	ftl::cuda::TextureObject<float4> centroid_vert_;
 	ftl::cuda::TextureObject<half4> normals_horiz_;
 
-	ftl::rgbd::Frame temp_;
+	ftl::data::Frame temp_;
 };
 
 /**
@@ -137,7 +137,7 @@ class AggreMLS : public ftl::operators::Operator {
  */
 class AdaptiveMLS : public ftl::operators::Operator {
 	public:
-	explicit AdaptiveMLS(ftl::Configurable*);
+	AdaptiveMLS(ftl::operators::Graph *g, ftl::Configurable*);
 	~AdaptiveMLS();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -145,7 +145,7 @@ class AdaptiveMLS : public ftl::operators::Operator {
 	bool apply(ftl::rgbd::Frame &in, ftl::rgbd::Frame &out, cudaStream_t stream) override;
 
 	private:
-	ftl::rgbd::Frame temp_;
+	ftl::data::Frame temp_;
 };
 
 }

components/operators/include/ftl/operators/weighting.hpp

@@ -22,7 +22,7 @@ namespace operators {
  */
 class PixelWeights : public ftl::operators::Operator {
 	public:
-	explicit PixelWeights(ftl::Configurable*);
+	PixelWeights(ftl::operators::Graph *g, ftl::Configurable*);
 	~PixelWeights();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -33,7 +33,7 @@ class PixelWeights : public ftl::operators::Operator {
 
 class CullWeight : public ftl::operators::Operator {
 	public:
-	explicit CullWeight(ftl::Configurable*);
+	CullWeight(ftl::operators::Graph *g, ftl::Configurable*);
 	~CullWeight();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }
@@ -44,7 +44,7 @@ class CullWeight : public ftl::operators::Operator {
 
 class DegradeWeight : public ftl::operators::Operator {
 	public:
-	explicit DegradeWeight(ftl::Configurable*);
+	DegradeWeight(ftl::operators::Graph *g, ftl::Configurable*);
 	~DegradeWeight();
 
 	inline Operator::Type type() const override { return Operator::Type::OneToOne; }

components/operators/src/antialiasing.cpp

@@ -4,7 +4,7 @@
 using ftl::operators::FXAA;
 using ftl::codecs::Channel;
 
-FXAA::FXAA(ftl::Configurable *cfg) : ftl::operators::Operator(cfg) {
+FXAA::FXAA(ftl::operators::Graph *g, ftl::Configurable *cfg) : ftl::operators::Operator(g, cfg) {
 
 }