add some change

MainWindow.cpp

@@ -6,6 +6,7 @@
 #include <QtConcurrent/QtConcurrent>
 
 #include "model/processor/BIP.h"
+#include "model/processor/strategies/Cri.h"
 #include "model/processor/strategies/DynCont.h"
 #include "model/processor/strategies/GrayMap.h"
 #include "model/processor/strategies/TintMap.h"
@@ -89,6 +90,7 @@ void MainWindow::registerStrategies()
 	REGISTER_STRATEGY(DynCont)
 	REGISTER_STRATEGY(Enhance)
 	REGISTER_STRATEGY(Persist)
+    REGISTER_STRATEGY(Cri)
 }
 
 void MainWindow::pushBackStrategy(const QString strategyName, const QString kernelFolder)
@@ -130,93 +132,111 @@ void MainWindow::readParam(QString path, int mode)
 		//sc
 	case 0:
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.linear, INP2MYFLT(temp) == 0);
+		_scenGenOutput.probe.linear = INP2MYFLT(temp) == 0;
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.depth, INP2MYFLT(temp));
+		OUT_WIDTH = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.probeRadius, INP2MYFLT(temp));
+		OUT_HEIGHT = INP2MYFLT(temp);
 
+		if(!_scenGenOutput.probe.linear)
+		{
 			temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.fieldOfView, INP2MYFLT(temp));
+			_scenGenOutput.probe.radius = INP2MYFLT(temp);
 
 			temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.probeFieldOfView, INP2MYFLT(temp));
+			_scenGenOutput.angle = INP2MYFLT(temp);
 
 			temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.virtualOriginalZ, INP2MYFLT(temp));
+			_scenGenOutput.maxScanAx = INP2MYFLT(temp);
+		}
+		temp = sl[index++].PARSE;
+		_scenGenOutput.depth = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.minScanAx, INP2MYFLT(temp));
+		_scenGenOutput.fieldOfView = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.minScanAz, INP2MYFLT(temp));
+		_scenGenOutput.bMinScanAx = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.maxScanAx, INP2MYFLT(temp));
+		_scenGenOutput.bMinScanAz = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.startDepth, INP2MYFLT(temp));
+		_scenGenOutput.bMaxScanAx = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.steering, INP2MYFLT(temp));
+		_scenGenOutput.bMaxScanAz = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.rxLineNo, INP2MYFLT(temp));
+		_scenGenOutput.minScanAx = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.rxFocusPointNo, INP2MYFLT(temp));
+		_scenGenOutput.minScanAz = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.rxLineDaz, INP2MYFLT(temp));
+		_scenGenOutput.startDepth = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.rxPointDax, INP2MYFLT(temp));
+		_scenGenOutput.steering = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.virtualConvex, INP2MYFLT(temp) != 0);
+		_scenGenOutput.rxLineNo = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.vcMaxTheta, INP2MYFLT(temp));
+		_scenGenOutput.rxFocusPointNo= INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field(&_scenGenOutput.angle, INP2MYFLT(temp));
+		_scenGenOutput.rxLineDaz = INP2MYFLT(temp);
+
+		temp = sl[index++].PARSE;
+		_scenGenOutput.rxPointDax = INP2MYFLT(temp);
+
+		if(_scenGenOutput.probe.linear)
+		{
+			temp = sl[index++].PARSE;
+			_scenGenOutput.virtualConvex = INP2MYFLT(temp) != 0;
+		}
+
+		temp = sl[index++].PARSE;
+		_scenGenOutput.hdZoom= INP2MYFLT(temp) != 0;
+
 		break;
 	case 1:
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.rejectThreshold, INP2MYFLT(temp));
+		_scenGenOutput.rejectThreshold = INP2MYFLT(temp);
 		break;
 	case 2:
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.sri, INP2MYFLT(temp));
+		_scenGenOutput.sri = INP2MYFLT(temp);
 		break;
 	case 3:
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.tintMapSelector, INP2MYFLT(temp));
+		_scenGenOutput.tintMapSelector = INP2MYFLT(temp);
 		break;
 	case 4:
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.grayMapSelector, INP2MYFLT(temp));
+		_scenGenOutput.grayMapSelector = INP2MYFLT(temp);
 		break;
 	case 5:
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.dynContSelector, INP2MYFLT(temp));
+		_scenGenOutput.dynContSelector = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.dynContGain, INP2MYFLT(temp));
+		_scenGenOutput.dynContGain = INP2MYFLT(temp);
 
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.compressionType, INP2MYFLT(temp));
+		_scenGenOutput.compressionType = INP2MYFLT(temp);
 		break;
 	case 6:
 		temp = sl[index++].PARSE;
-		update_field<int>(&_scenGenOutput.enhance, INP2MYFLT(temp));
+		_scenGenOutput.enhance = INP2MYFLT(temp);
 
-		update_field<int>(&_scenGenOutput.enhanceAlgorithm, 0);
+		_scenGenOutput.enhanceAlgorithm =  0;
 		break;
 	case 7:
-		update_field<int>(&_scenGenOutput.persist, 1);
+		_scenGenOutput.persist = 1;
 		break;
 	}
 }
@@ -288,8 +308,8 @@ void MainWindow::on_btn_test_clicked()
 				return;
 			}
 
-			OUT_WIDTH = ui->cb_kernelName->currentIndex() ? width : 1000;
+//			OUT_WIDTH = ui->cb_kernelName->currentIndex() ? width : 1000;
-			OUT_HEIGHT = ui->cb_kernelName->currentIndex() ? height : 1000;
+//			OUT_HEIGHT = ui->cb_kernelName->currentIndex() ? height : 1000;
 
 			ImageFormat format;
 			format.image_channel_order = CL_RGBA;
@@ -307,9 +327,19 @@ void MainWindow::on_btn_test_clicked()
 									  width * sizeof (myflt),
 									  0,
 									  arr.data());
-
+//            if(ui->cb_kernelName->currentText() == "Cri")
-			update_field(&_scenGenOutput.outputWidth, (uint)OUT_WIDTH);
+//            {
-			update_field(&_scenGenOutput.outputHeight, (uint)OUT_HEIGHT);
+//                Image2D* criBuffer[16];
+//                auto bufferPath = inputDir.path() + "/buffer";
+//                for (int i = 1; i <= 16; ++i)
+//                {
+//                    auto bfname = QString("%1\%2\")
+
+//                }
+
+//            }
+			_scenGenOutput.outputWidth = (uint)OUT_WIDTH;
+			_scenGenOutput.outputHeight = (uint)OUT_HEIGHT;
 			_strategy->cpuProcess(_scenGenOutput);
 
 			auto outFrame = _strategy->processKernel(inFrame, _scratchPad);

MainWindow.h

@@ -63,7 +63,7 @@ private:
 	void registerStrategies();
 	void pushBackStrategy(const QString strategyName, const QString kernelFolder);
 	IProcessStrategy* _strategy;
-	ScenGenOutput_t _scenGenOutput;
+	Input_t _scenGenOutput;
 
 	void readParam(QString path, int mode);
 

header/ELogId.h

@@ -145,9 +145,9 @@ public:
 	 * Converts the eLogId enumerator to the relevant identification number
 	 */
 
-	static int qtEnumToInt(const eLogId qtEnum)
+	static int qtEnumToInt(const QString key)
 	{
-		return QMetaEnum::fromType<eLogId>().value(qtEnum);
+		return static_cast<quint8> (QMetaEnum::fromType<eLogId>().keyToValue(key.toStdString().c_str()));
 	}
 };
 

header/ScenarioParams.h

@@ -3,53 +3,52 @@
 
 #include <QObject>
 
-template<typename T>
+typedef struct ProbeProperties_t
-struct field_t
 {
-	T value;
+	bool linear;
-	bool isUpdated;
+	float radius;
-};
+	float fieldOfView;
+}ProbeProperties_t;
 
-typedef struct ScenGenOutput_t
+typedef struct Input_t
 {
-	field_t<bool> linear;
+	ProbeProperties_t probe;
-	field_t<bool> virtualConvex;
+	bool virtualConvex;
-	field_t<float> depth;
+	bool hdZoom;
-	field_t<float> probeRadius;
+	float depth;
-	field_t<float> fieldOfView;
+	float fieldOfView;
-	field_t<float> probeFieldOfView;
+	float startDepth;
-	field_t<float> startDepth;
+	int rxLineNo;
-	field_t<int> rxLineNo;
+	int rxFocusPointNo;
-	field_t<int> rxFocusPointNo;
+	float rxLineDaz;
-	field_t<float> rxLineDaz;
+	float rxPointDax;
-	field_t<float> rxPointDax;
+	float vcMaxTheta;
-	field_t<float> vcMaxTheta;
+	float angle;
-	field_t<float> angle;
+	float steering;
-	field_t<float> steering;
+	float minScanAx;
-	field_t<float> minScanAx;
+	float maxScanAx;
-	field_t<float> minScanAz;
+	float minScanAz;
-	field_t<float> maxScanAx;
+	float bMinScanAx;
-	field_t<float> virtualOriginalZ;
+	float bMinScanAz;
-	field_t<uint> outputWidth;
+	float bMaxScanAx;
-	field_t<uint> outputHeight;
+	float bMaxScanAz;
-	field_t<int> compressionType;
+	float virtualOriginalZ;
-	field_t<int> dynContSelector;
+	uint outputWidth;
-	field_t<int> dynContGain;
+	uint outputHeight;
-	field_t<int> grayMapSelector;
+	int compressionType;
-	field_t<int> tintMapSelector;
+	int dynContSelector;
-	field_t<int> sri;
+	int dynContGain;
-	field_t<int> rejectThreshold;
+	int grayMapSelector;
-	field_t<int> enhance;
+	int tintMapSelector;
-	field_t<int> enhanceAlgorithm;
+	int sri;
-	field_t<int> persist;
+	int rejectThreshold;
-}ScenGenOutput_t;
+	int enhance;
-
+	int enhanceAlgorithm;
-template<typename T>
+	int persist;
-void update_field(field_t<T> *t, T value)
+	int criFilterMode;//cri
-{
+	int frameCntr;//cri
-	t->value = value;
+	int scenarioFrameNo;//cri
-	t->isUpdated = true;
+}Input_t;
-}
 
 
 #endif // SCENARIOPARAMS_H

header/Utils.h

@@ -13,12 +13,12 @@ typedef float myflt;
 typedef int myint;
 #endif
 
-#define INP2MYFLT(x) *((myflt*)(&x))
+#define INP2MYFLT(x) *(reinterpret_cast<float *>(&x))
 
 #ifdef USE_DBL
 #define PARSE   toULong(Q_NULLPTR, 16)
 #else
-#define PARSE   toInt(Q_NULLPTR, 16)
+#define PARSE   toUInt(Q_NULLPTR, 16)
 #endif
 
 

header/model/algorithms/ScanConversionAlg.h

@@ -0,0 +1,35 @@
+#ifndef SCANCONVERSIONALG_H
+#define SCANCONVERSIONALG_H
+
+#include "./ScenarioParams.h"
+
+class ScanConversionAlg
+{
+private:
+	static void linear(Input_t params, QVector<float>& scanXPos, QVector<float>& scanZPos,
+					   QVector<float>& gridPixelXPos, QVector<float>& gridPixelZPos);
+
+	static void virtualConvex(Input_t params, QVector<float>& scanXPos, QVector<float>& scanZPos,
+							  QVector<float>& gridPixelXPos, QVector<float>& gridPixelZPos);
+
+	static void convex(Input_t params, QVector<float>& scanXPos, QVector<float>& scanZPos,
+					   QVector<float>& gridPixelXPos, QVector<float>& gridPixelZPos);
+
+public:
+	static void scanConversion(Input_t params, QVector<float>& scanXPos, QVector<float>& scanZPos,
+							   QVector<float>& gridPixelXPos, QVector<float>& gridPixelZPos);
+
+	static void virtualScanConversion(QVector<float> pixelXPos, QVector<float> pixelZPos,
+									  uint width, uint height,
+									  float steering, float virtualOriginalZ,
+									  float startDepth, float depth, float vcMaxTheta,
+									  QVector<float>& gridPixelR, QVector<float>& gridPixelTheta);
+
+	static void convexScanConversion(QVector<float> pixelXPos, QVector<float> pixelZPos,
+									 uint width, uint height,
+									 float steering, float angle, float fieldOfView,
+									 float probeRadius, float startDepth, float depth,
+									 QVector<float>& gridPixelR,  QVector<float>& gridPixelTheta);
+};
+
+#endif // SCANCONVERSIONALG_H

header/model/processor/IProcessStrategy.h

@@ -22,7 +22,7 @@ class IProcessStrategy : public QObject
 	Q_OBJECT
 
 public:
-	virtual void cpuProcess(ScenGenOutput_t parameters) = 0;
+	virtual void cpuProcess(Input_t parameters) = 0;
 	virtual void finalize() = 0;
 		virtual Image* processKernel(Image* inputFrame, Buffer* scrathPad) = 0;
 

header/model/processor/strategies/Cri.h

@@ -0,0 +1,35 @@
+#ifndef CRI_H
+#define CRI_H
+
+#include <QObject>
+#include <QMetaType>
+
+#include "model/processor/IProcessStrategy.h"
+#include "utils/OpenCLHelper.h"
+
+#define CRI_MAX_BUFFER_SIZE     16
+
+
+typedef struct Cri_t
+{
+ cl_int criFilterMode;
+ cl_int frameCntr;
+ cl_int scenariFrameNo;
+}Cri_t;
+
+
+class Cri : public IProcessStrategy
+{
+    Q_OBJECT
+public:
+   Q_INVOKABLE Cri(const Context context, const QString kernelPath, const QObject *parent);
+   virtual void cpuProcess(Input_t parameters) override;
+   virtual void finalize() override;
+
+private:
+   KernelFunctor<Image2DArray, Image2D, Cri_t> _kernelFunctor;
+   virtual Image* processKernel(Image *frames, Buffer* scratchPad) override;
+   Cri_t _kernelParameters;
+   Image2D* _criBuffer[CRI_MAX_BUFFER_SIZE];
+};
+#endif // CRI_H

header/model/processor/strategies/DynCont.h

@@ -20,7 +20,7 @@ class DynCont : public IProcessStrategy
 	Q_OBJECT
 public:
    Q_INVOKABLE DynCont(const Context context, const QString kernelPath, const QObject *parent);
-   virtual void cpuProcess(ScenGenOutput_t parameters) override;
+   virtual void cpuProcess(Input_t parameters) override;
    virtual void finalize() override;
 
 private:

header/model/processor/strategies/Enhance.h

@@ -20,7 +20,7 @@ class Enhance : public IProcessStrategy
 	Q_OBJECT
 public:
    Q_INVOKABLE Enhance(const Context context, const QString kernelPath, const QObject *parent);
-   virtual void cpuProcess(ScenGenOutput_t parameters) override;
+   virtual void cpuProcess(Input_t parameters) override;
    virtual void finalize() override;
 
 private:

header/model/processor/strategies/GrayMap.h

@@ -17,7 +17,7 @@ class GrayMap : public IProcessStrategy
 	Q_OBJECT
 public:
    Q_INVOKABLE GrayMap(const Context context, const QString kernelPath, const QObject *parent);
-   virtual void cpuProcess(ScenGenOutput_t parameters) override;
+   virtual void cpuProcess(Input_t parameters) override;
    virtual void finalize() override;
 
 private:

header/model/processor/strategies/Persist.h

@@ -20,7 +20,7 @@ class Persist : public IProcessStrategy
 	Q_OBJECT
 public:
    Q_INVOKABLE Persist(const Context context, const QString kernelPath, const QObject *parent);
-   virtual void cpuProcess(ScenGenOutput_t parameters) override;
+   virtual void cpuProcess(Input_t parameters) override;
    virtual void finalize() override;
 
 private:

header/model/processor/strategies/Rejection.h

@@ -16,7 +16,7 @@ class Rejection : public IProcessStrategy
 	Q_OBJECT
 public:
    Q_INVOKABLE Rejection(const Context context, const QString kernelPath);
-   virtual void cpuProcess(ScenGenOutput_t parameters) override;
+   virtual void cpuProcess(Input_t parameters) override;
    virtual void finalize() override;
 
 

header/model/processor/strategies/ScanConversion.h

@@ -19,7 +19,7 @@ class ScanConversion : public IProcessStrategy
 public:
 	Q_INVOKABLE ScanConversion(const Context context, const QString kernelPath,
 							   const QObject* parent);
-	virtual void cpuProcess(ScenGenOutput_t parameters) override;
+	virtual void cpuProcess(Input_t parameters) override;
 	virtual void finalize() override;
 
 
@@ -30,12 +30,10 @@ private:
 	quint64 _width;
 	quint64 _height;
 
-	myflt* _gridPixelXPos;
+	QVector<float> _gridPixelXPos;
-	myflt* _gridPixelZPos;
+	QVector<float> _gridPixelZPos;
-	myflt* _gridPixelR;
+	QVector<float> _scanXPos;
-	myflt* _gridPixelTheta;
+	QVector<float> _scanZPos;
-	myflt* _scanXPos;
-	myflt* _scanZPos;
 
 	Buffer* _gridX;
 	Buffer* _gridZ;

header/model/processor/strategies/Sri.h

@@ -20,7 +20,7 @@ class Sri : public IProcessStrategy
 	Q_OBJECT
 public:
    Q_INVOKABLE Sri(const Context context, const QString kernelPath, const QObject *parent);
-   virtual void cpuProcess(ScenGenOutput_t parameters) override;
+   virtual void cpuProcess(Input_t parameters) override;
    virtual void finalize() override;
 
 private:

header/model/processor/strategies/TintMap.h

@@ -17,7 +17,7 @@ class TintMap : public IProcessStrategy
 	Q_OBJECT
 public:
    Q_INVOKABLE TintMap(const Context context, const QString kernelPath, const QObject *parent);
-   virtual void cpuProcess(ScenGenOutput_t parameters) override;
+   virtual void cpuProcess(Input_t parameters) override;
    virtual void finalize() override;
 
 private:

header/utils/OpenCLHelper.h

@@ -169,7 +169,9 @@ std::vector<Device> OpenCLHelper::getDevices(std::vector<Platform> platforms)
 				QString logText = "Devices registered successfuly: \"";
 				for (auto deviceIt = devices.begin(); deviceIt != devices.end(); deviceIt++)
 				{
-					logText = logText + QString::fromStdString(deviceIt->getInfo<CL_DEVICE_NAME>() + ",");
+                    logText = logText + QString::fromStdString(deviceIt->getInfo<CL_DEVICE_NAME>() + " : ") +
+                            QString::fromStdString(deviceIt->getInfo<CL_DEVICE_VERSION>() + " , ") +
+                            QString::fromStdString(deviceIt->getInfo<CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE>() + " ,");
 				}
 				logText = logText + "\"";
 				handleError(ESeverityLevel::Debug,

kernels/Cri.cl

@@ -0,0 +1,16 @@
+
+struct input
+{
+ int criFilterMode;
+ int frameCntr;
+ int scenariFrameNo;
+};
+
+kernel void Cri(read_only image2d_array_t input_frame, read_write image2d_t output_frame, struct input params)
+{
+    const int rows = get_image_height(input_frame);
+    const int cols = get_image_width(input_frame);
+    int4 f = read_imagei(input_frame, (rows,cols,1,1));
+    printf("out: %a | ", f.x);
+    // printf("   :hi! I am the cri kernel");
+}

kernels/ScanConversion.cl

@@ -1,6 +1,6 @@
-//#define TEST
+#define TEST
-#define X	0
+#define X	379
-#define Y	0
+#define Y	142
 
 //#define USE_DBL
 #ifdef USE_DBL
@@ -51,13 +51,15 @@ TYPE_FLT mabs(TYPE_FLT arg)
 kernel void ScanConversion(read_only image2d_t input_frame, read_write image2d_t output_frame, 
                           global TYPE_FLT* grid_x, global TYPE_FLT* grid_z, 
                           global TYPE_FLT* query_x, global TYPE_FLT* query_z,
-                          struct input params) {
+                          struct input params)
+{
   int2 gid = (int2)(get_global_id(0), get_global_id(1));
   TYPE_FLT dx = grid_x[1] - grid_x[0];
   TYPE_FLT dz = grid_z[1] - grid_z[0];
   TYPE_FLT x = query_x[gid.y * params.output_width + gid.x];
   TYPE_FLT z = query_z[gid.y * params.output_width + gid.x];
 
+
   int grid_x_index = 0;
   int grid_z_index = 0;
 
@@ -67,11 +69,15 @@ kernel void ScanConversion(read_only image2d_t input_frame, read_write image2d_t
     grid_x_index = floor((x - grid_x[0]) / dx);
 
   if(mabs(z - grid_z[params.grid_z_size - 1]) < EPSILSON)
+  {
     grid_z_index = params.grid_z_size - 2;
+  }
   else
+  {
     grid_z_index = floor((z - grid_z[0]) / dz);
-
+  }
   TYPE_FLT output_data = 0;
+
   if(grid_x_index >= 0 && grid_x_index < params.grid_x_size - 1 && 
     grid_z_index >= 0 && grid_z_index < params.grid_z_size - 1)
   {

source/FileHelper.cpp

@@ -64,7 +64,7 @@ bool FileHelper::ReadInputFile(myint *arr, QString path, quint64 *width, quint64
 		if(str.length() == 0)
 			break;
 		(*height)++;
-		str = str.remove(str.length() - 1, 1);
+//		str = str.remove(str.length() - 1, 1);
 		auto sl = str.split(",");
 		if(first)
 		{
@@ -78,7 +78,7 @@ bool FileHelper::ReadInputFile(myint *arr, QString path, quint64 *width, quint64
 		}
 		for(int i = 0; i < sl.length(); i++)
 		{
-			auto x = sl[i].PARSE;
+            auto x = sl[i].toInt(Q_NULLPTR,16);
 			arr[index++] = x;
 		}
 	}

source/model/algorithms/ScanConversionAlg.cpp

@@ -0,0 +1,518 @@
+#include "model/algorithms/ScanConversionAlg.h"
+
+#include <QtMath>
+
+void ScanConversionAlg::linear(Input_t params, QVector<float> &scanXPos, QVector<float> &scanZPos,
+							QVector<float> &gridPixelXPos, QVector<float> &gridPixelZPos)
+{
+	//just to map to X Z convention
+	auto frameMaxXScan = params.bMaxScanAz;
+	auto frameMinXScan = params.bMinScanAz;
+	auto frameMaxZScan = params.bMaxScanAx;
+	auto frameMinZScan = params.bMinScanAx;
+
+	auto finalPixelXNo = params.outputWidth;
+	auto finalPixelZNo = params.outputHeight;
+
+	auto pixelXStep = (frameMaxXScan - frameMinXScan) / (finalPixelXNo - 1);
+	auto pixelZStep = (frameMaxZScan - frameMinZScan) / (finalPixelZNo - 1);
+
+	gridPixelXPos.reserve(finalPixelXNo * finalPixelZNo);
+	gridPixelZPos.reserve(finalPixelXNo * finalPixelZNo);
+
+	auto cap = gridPixelXPos.capacity();
+
+	for(auto i = 0UL; i < finalPixelZNo; i++)
+	{
+		auto temp = frameMinZScan + i * pixelZStep;
+		for(auto j = 0UL; j < finalPixelXNo; j++)
+		{
+			gridPixelZPos.push_back(temp / cosf(params.steering));
+			gridPixelXPos.push_back((frameMinXScan + j * pixelXStep) -
+									(temp * tanf(params.steering)));
+		}
+	}
+
+	for(auto i = 0; i < params.rxLineNo; i++)
+	{
+		scanXPos.push_back(params.minScanAz + i * params.rxLineDaz);
+	}
+
+	for(auto i = 0; i < params.rxFocusPointNo; i++)
+	{
+		scanZPos.push_back(params.minScanAx + i * params.rxPointDax);
+	}
+}
+
+/*************************************************************************************************/
+void ScanConversionAlg::virtualConvex(Input_t params, QVector<float>& scanXPos,
+									  QVector<float>& scanZPos, QVector<float>& gridPixelXPos,
+									  QVector<float>& gridPixelZPos)
+{
+	auto finalPixelXNo = params.outputWidth;
+	auto finalPixelZNo = params.outputHeight;
+
+	auto minAbsScanAz = 0.0f;
+	if (params.bMaxScanAz > 0 && params.bMinScanAz < 0)
+	{
+		minAbsScanAz = 0;
+	}
+	else
+	{
+		minAbsScanAz = qMin(abs(params.bMinScanAz), abs(params.bMaxScanAz));
+	}
+
+	auto maxAbsScanAz = qMax(abs(params.bMinScanAz), abs(params.bMaxScanAz));
+	auto frameMaxZScan = params.bMaxScanAx *
+			cosf(minAbsScanAz / params.fieldOfView * 2 * params.vcMaxTheta);
+	auto frameMinZScan = params.bMinScanAx *
+			cosf(maxAbsScanAz / params.fieldOfView * 2 * params.vcMaxTheta);
+	auto frameMaxXScan = params.bMaxScanAz + params.bMaxScanAx *
+			sinf(params.bMaxScanAz / params.fieldOfView * 2 * params.vcMaxTheta);
+	auto frameMinXScan = params.bMinScanAz + params.bMaxScanAx *
+			sinf(params.bMinScanAz / params.fieldOfView * 2 * params.vcMaxTheta);
+
+
+	auto pixelXStep = (frameMaxXScan - frameMinXScan) / (finalPixelXNo - 1);
+	auto pixelZStep = (frameMaxZScan - frameMinZScan) / (finalPixelZNo - 1);
+
+	auto pixelXPos = QVector<float>();
+	auto pixelZPos = QVector<float>();
+
+	pixelXPos.reserve(finalPixelXNo * finalPixelZNo);
+	pixelZPos.reserve(finalPixelXNo * finalPixelZNo);
+
+	for(auto i = 0UL; i < finalPixelZNo; i++)
+	{
+		for(auto j = 0UL; j < finalPixelXNo; j++)
+		{
+			pixelZPos.push_back(frameMinZScan + i * pixelZStep);
+			pixelXPos.push_back(frameMinXScan + j * pixelXStep);
+		}
+	}
+
+	virtualScanConversion(pixelXPos, pixelZPos, finalPixelXNo, finalPixelZNo, params.steering,
+						  params.virtualOriginalZ, params.startDepth, params.depth,
+						  params.vcMaxTheta, gridPixelZPos, gridPixelXPos);
+
+	//scanTheta
+	for(auto i = 0; i < params.rxLineNo; i++)
+	{
+		scanXPos.push_back(params.minScanAz + i * params.rxLineDaz);
+	}
+
+	//scanR
+	for(auto i = 0; i < params.rxFocusPointNo; i++)
+	{
+		scanZPos.push_back(params.minScanAx + i * params.rxPointDax);
+	}
+}
+
+/*************************************************************************************************/
+void ScanConversionAlg::convex(Input_t params, QVector<float>& scanXPos, QVector<float>& scanZPos,
+							   QVector<float>& gridPixelXPos, QVector<float>& gridPixelZPos)
+{
+	auto finalPixelXNo = params.outputWidth;
+	auto finalPixelZNo = params.outputHeight;
+
+	auto frameMaxXScan = params.probe.radius * sinf(params.bMaxScanAz) +
+			params.bMaxScanAx * sinf(params.bMaxScanAz / params.fieldOfView * params.angle);
+	auto frameMinXScan = params.probe.radius * sinf(params.bMinScanAz) +
+			params.bMaxScanAx * sinf(params.bMinScanAz / params.fieldOfView * params.angle);
+
+	auto minAbsScanAz = 0.0f;
+	if (params.bMaxScanAz > 0 && params.bMinScanAz < 0)
+	{
+		minAbsScanAz = 0;
+	}
+	else
+	{
+		minAbsScanAz = qMin(abs(params.bMinScanAz), abs(params.bMaxScanAz));
+	}
+	auto maxAbsScanAz = qMax(abs(params.bMinScanAz), abs(params.bMaxScanAz));
+
+	auto frameMaxZScan = params.probe.radius * cosf(minAbsScanAz) +
+			params.bMaxScanAx * cosf(minAbsScanAz / params.fieldOfView * params.angle);
+	auto frameMinZScan = params.probe.radius * cosf(maxAbsScanAz) +
+			params.bMinScanAx * cosf(maxAbsScanAz / params.fieldOfView * params.angle);
+
+	auto pixelXStep = (frameMaxXScan - frameMinXScan) / (finalPixelXNo - 1);
+	auto pixelZStep = (frameMaxZScan - frameMinZScan) / (finalPixelZNo - 1);
+
+	auto pixelXPos = QVector<float>();
+	auto pixelZPos = QVector<float>();
+
+	pixelXPos.reserve(finalPixelXNo * finalPixelZNo);
+	pixelZPos.reserve(finalPixelXNo * finalPixelZNo);
+
+	for(auto i = 0UL; i < finalPixelZNo; i++)
+	{
+		for(auto j = 0UL; j < finalPixelXNo; j++)
+		{
+			pixelZPos.push_back(frameMinZScan + i * pixelZStep);
+			pixelXPos.push_back(frameMinXScan + j * pixelXStep);
+		}
+	}
+
+	convexScanConversion(pixelXPos, pixelZPos, finalPixelXNo, finalPixelZNo, params.steering,
+						 params.angle, params.fieldOfView, params.probe.radius, params.startDepth,
+						 params.depth, gridPixelZPos, gridPixelXPos);
+
+
+	//scanTheta
+	for(auto i = 0; i < params.rxLineNo; i++)
+	{
+		scanXPos.push_back(params.minScanAz + i * params.rxLineDaz + params.probe.radius);
+	}
+
+	//scanR
+	for(auto i = 0; i < params.rxFocusPointNo; i++)
+	{
+		scanZPos.push_back(params.minScanAx + i * params.rxPointDax);
+	}
+}
+
+/*************************************************************************************************/
+void ScanConversionAlg::scanConversion(Input_t params, QVector<float>& scanXPos,
+									   QVector<float>& scanZPos, QVector<float>& gridPixelXPos,
+									   QVector<float>& gridPixelZPos)
+{
+	//convex
+	if(!params.probe.linear)
+	{
+		convex(params, scanXPos, scanZPos, gridPixelXPos, gridPixelZPos);
+	}
+	//virtual convex
+	else if(params.virtualConvex)
+	{
+		virtualConvex(params, scanXPos, scanZPos, gridPixelXPos, gridPixelZPos);
+	}
+	//linear
+	else
+	{
+		linear(params, scanXPos, scanZPos, gridPixelXPos, gridPixelZPos);
+	}
+}
+
+/*************************************************************************************************/
+void ScanConversionAlg::virtualScanConversion(QVector<float> pixelXPos, QVector<float> pixelZPos,
+											  uint width, uint height, float steering,
+											  float virtualOriginalZ, float startDepth, float depth,
+											  float vcMaxTheta, QVector<float>& gridPixelR,
+											  QVector<float>& gridPixelTheta)
+{
+	for(auto i = 0U; i < width * height; i++)
+	{
+		auto x = pixelXPos[i];
+		auto z = pixelZPos[i];
+
+		auto pixelTheta = atanf(x / (z + virtualOriginalZ));
+
+		if(pixelTheta >= -vcMaxTheta - abs(steering) &&
+			pixelTheta <= vcMaxTheta + abs(steering))
+		{
+			if(steering == 0.0f)
+			{
+				auto gridPixelAx = sqrtf(powf(x - virtualOriginalZ * tanf(pixelTheta), 2) +
+										 powf(z, 2));
+
+				if(gridPixelAx >= startDepth &&	gridPixelAx <= depth)
+				{
+					gridPixelR.push_back(gridPixelAx);
+					gridPixelTheta.push_back(pixelTheta);
+				}
+				else
+				{
+					gridPixelR.push_back(0);
+					gridPixelTheta.push_back(0);
+				}
+			}
+			else
+			{
+				auto strTan = tanf(steering);
+				auto a = virtualOriginalZ * strTan;
+				auto b = x * strTan + virtualOriginalZ + z;
+				auto c = x - z * strTan;
+				auto interceptTheta = atanf((b + sqrtf(powf(b, 2) - 4 * a * c)) / (2 * a));
+				if(interceptTheta > vcMaxTheta || interceptTheta < -vcMaxTheta)
+				{
+					interceptTheta = atanf((b - sqrtf(powf(b, 2) - 4 * a * c)) / (2 * a));
+					if(interceptTheta > vcMaxTheta || interceptTheta < -vcMaxTheta)
+					{
+						gridPixelR.push_back(0);
+						gridPixelTheta.push_back(0);
+					}
+					else
+					{
+						auto gridPixelAx =
+								sqrtf(powf(x - virtualOriginalZ * tanf(interceptTheta), 2) +
+									  powf(z, 2));
+						if(gridPixelAx >= startDepth &&	gridPixelAx <= depth)
+						{
+							gridPixelR.push_back(gridPixelAx);
+							gridPixelTheta.push_back(interceptTheta);
+						}
+						else
+						{
+							gridPixelR.push_back(0);
+							gridPixelTheta.push_back(0);
+						}
+					}
+				}
+				else
+				{
+					auto gridPixelAx =
+							sqrtf(powf(x - virtualOriginalZ * tanf(interceptTheta), 2) +
+								  powf(z, 2));
+					if(gridPixelAx >= startDepth &&	gridPixelAx <= depth)
+					{
+						gridPixelR.push_back(gridPixelAx);
+						gridPixelTheta.push_back(interceptTheta);
+					}
+					else
+					{
+						gridPixelR.push_back(0);
+						gridPixelTheta.push_back(0);
+					}
+				}
+			}//steering = 0
+		}
+		else
+		{
+			gridPixelR.push_back(0);
+			gridPixelTheta.push_back(0);
+		}
+	}
+}
+
+/*************************************************************************************************/
+void ScanConversionAlg::convexScanConversion(QVector<float> pixelXPos, QVector<float> pixelZPos,
+											 uint width, uint height, float steering, float angle,
+											 float fieldOfView, float probeRadius, float startDepth,
+											 float depth, QVector<float>& gridPixelR,
+											 QVector<float>& gridPixelTheta)
+{
+	auto virtualOriginalZ  = probeRadius *
+			(cosf(fieldOfView / 2) - sinf(fieldOfView / 2) / tanf(angle / 2));
+	auto virtualOriginalZ2 = powf(virtualOriginalZ, 2);
+
+	auto maxR = probeRadius + depth;
+	auto minR = probeRadius - virtualOriginalZ + startDepth;
+
+	auto minTheta = -angle / 2 - abs(steering);
+	auto maxTheta = angle / 2 + abs(steering);
+
+	auto maxInterceptTheta = fieldOfView / 2;
+	auto radius2 = powf(probeRadius, 2);
+
+	if(steering == 0.0f)
+	{
+		for (auto i = 0U; i < width * height; i++)
+		{
+			auto x = pixelXPos[i];
+			auto z = pixelZPos[i];
+
+			auto pixelTheta = atan2f(x, z - virtualOriginalZ);
+			auto pixelR = sqrtf(powf(x, 2) + powf(z - virtualOriginalZ, 2));
+
+			if(pixelR >= minR && pixelR <= maxR && pixelTheta >= minTheta && pixelTheta <= maxTheta)
+			{
+				auto interceptTheta = 0.0f;
+				auto interceptX = 0.0f;
+				auto interceptZ = 0.0f;
+				auto alpha = 0.0f;
+				auto beta = 0.0f;
+
+				if(x == 0.0f)
+					interceptTheta = 0;
+				else
+				{
+					alpha = virtualOriginalZ;
+					beta = (virtualOriginalZ - z) / x;
+					interceptX = (alpha * beta +
+								  sqrtf(-1 * powf(alpha, 2) + (powf(beta, 2) + 1) * radius2)) /
+							(powf(beta, 2) + 1);
+					interceptZ = alpha - beta * interceptX;
+					interceptTheta = atan2f(interceptX, interceptZ);
+				}
+
+				if(interceptTheta >  maxInterceptTheta || interceptTheta < -maxInterceptTheta)
+				{
+					interceptX = (alpha * beta -
+								  sqrtf(-1 * powf(alpha, 2) + (powf(beta, 2) + 1) * radius2)) /
+							(powf(beta, 2) + 1);
+					interceptZ = alpha - beta * interceptX;
+					interceptTheta = atan2f(interceptX, interceptZ);
+
+					if(interceptTheta > maxInterceptTheta || interceptTheta < -maxInterceptTheta)
+					{
+						gridPixelR.push_back(0);
+						gridPixelTheta.push_back(0);
+					}
+					else
+					{
+						auto gridPixelAx = sqrtf(powf(x - probeRadius * sinf(interceptTheta), 2) +
+												 powf(z - probeRadius * cosf(interceptTheta), 2));
+						if(gridPixelAx >= startDepth && gridPixelAx <= depth)
+						{
+							gridPixelR.push_back(probeRadius + gridPixelAx);
+							gridPixelTheta.push_back(interceptTheta);
+						}
+						else
+						{
+							gridPixelR.push_back(0);
+							gridPixelTheta.push_back(0);
+						}
+					}
+				}
+				else
+				{
+					auto gridPixelAx = sqrtf(powf(x - probeRadius * sinf(interceptTheta), 2) +
+											 powf(z - probeRadius * cosf(interceptTheta), 2));
+					if(gridPixelAx >= startDepth && gridPixelAx <= depth)
+					{
+						gridPixelR.push_back(probeRadius + gridPixelAx);
+						gridPixelTheta.push_back(interceptTheta);
+					}
+					else
+					{
+						gridPixelR.push_back(0);
+						gridPixelTheta.push_back(0);
+					}
+				}
+			}
+			else
+			{
+				gridPixelR.push_back(0);
+				gridPixelTheta.push_back(0);
+			}
+		}
+	}
+	else
+	{
+		for (auto i = 0U; i < width * height; i++)
+		{
+			auto x = pixelXPos[i];
+			auto z = pixelZPos[i];
+
+			auto pixelTheta = atan2f(x, z - virtualOriginalZ);
+			auto pixelR = sqrtf(powf(x, 2) + powf(z - virtualOriginalZ, 2));
+
+			if(pixelR >= minR && pixelR <= maxR && pixelTheta >= minTheta && pixelTheta <= maxTheta)
+			{
+				auto strSin = 2 * sinf(steering);
+				auto ro = pixelR / strSin;
+				auto xo = ro * cosf(steering - pixelTheta);
+				auto zo = ro * sinf(steering - pixelTheta) + virtualOriginalZ;
+				if(zo == 0.0f)
+				{
+					auto interceptX = (radius2 - virtualOriginalZ2) / 2 / xo;
+					auto interceptZ = sqrtf(radius2 - powf(interceptX , 2));
+					auto interceptTheta = atan2f(interceptX, interceptZ);
+					if (interceptTheta > maxInterceptTheta || interceptTheta < -maxInterceptTheta)
+					{
+						interceptZ = -sqrtf(radius2 - powf(interceptX , 2));
+						interceptTheta = atan2f(interceptX, interceptZ);
+						if(interceptTheta >  maxInterceptTheta ||
+								interceptTheta < -maxInterceptTheta)
+						{
+							gridPixelR.push_back(0);
+							gridPixelTheta.push_back(0);
+						}
+						else
+						{
+							auto gridPixelAx =
+									sqrtf(powf(x - probeRadius * sinf(interceptTheta), 2) +
+										  powf(z - probeRadius * cosf(interceptTheta), 2));
+							if(gridPixelAx >= startDepth && gridPixelAx <= depth)
+							{
+								gridPixelR.push_back(probeRadius + gridPixelAx);
+								gridPixelTheta.push_back(interceptTheta);
+							}
+							else
+							{
+								gridPixelR.push_back(0);
+								gridPixelTheta.push_back(0);
+							}
+						}
+					}
+					else
+					{
+						auto gridPixelAx = 	sqrtf(powf(x - probeRadius * sinf(interceptTheta), 2) +
+												  powf(z - probeRadius * cosf(interceptTheta), 2));
+						if(gridPixelAx >= startDepth && gridPixelAx <= depth)
+						{
+							gridPixelR.push_back(probeRadius + gridPixelAx);
+							gridPixelTheta.push_back(interceptTheta);
+						}
+						else
+						{
+							gridPixelR.push_back(0);
+							gridPixelTheta.push_back(0);
+						}
+					}
+				}
+				else
+				{
+					auto alpha = (radius2 - virtualOriginalZ2 + 2 * zo * virtualOriginalZ) / 2 / zo;
+					auto beta = xo / zo;
+
+					auto interceptX = (alpha * beta +
+									   sqrtf(-1 * powf(alpha, 2) + (powf(beta, 2) + 1) * radius2)) /
+							(powf(beta, 2) + 1);
+					auto interceptZ = alpha - beta * interceptX;
+					auto interceptTheta = atan2f(interceptX, interceptZ);
+
+					if(interceptTheta > maxInterceptTheta || interceptTheta < -maxInterceptTheta)
+					{
+						interceptX = (alpha * beta -
+									  sqrtf(-1 * powf(alpha, 2) + (powf(beta, 2) + 1) * radius2)) /
+								(powf(beta, 2) + 1);
+						interceptZ = alpha - beta * interceptX;
+						interceptTheta = atan2f(interceptX, interceptZ);
+						if(interceptTheta > maxInterceptTheta || interceptTheta < -maxInterceptTheta)
+						{
+							gridPixelR.push_back(0);
+							gridPixelTheta.push_back(0);
+						}
+						else
+						{
+							auto gridPixelAx = 	sqrtf(powf(x - probeRadius * sinf(interceptTheta), 2) +
+													  powf(z - probeRadius * cosf(interceptTheta), 2));
+							if(gridPixelAx >= startDepth && gridPixelAx <= depth)
+							{
+								gridPixelR.push_back(probeRadius + gridPixelAx);
+								gridPixelTheta.push_back(interceptTheta);
+							}
+							else
+							{
+								gridPixelR.push_back(0);
+								gridPixelTheta.push_back(0);
+							}
+						}
+					}
+					else
+					{
+						auto gridPixelAx = 	sqrtf(powf(x - probeRadius * sinf(interceptTheta), 2) +
+												  powf(z - probeRadius * cosf(interceptTheta), 2));
+						if(gridPixelAx >= startDepth && gridPixelAx <= depth)
+						{
+							gridPixelR.push_back(probeRadius + gridPixelAx);
+							gridPixelTheta.push_back(interceptTheta);
+						}
+						else
+						{
+							gridPixelR.push_back(0);
+							gridPixelTheta.push_back(0);
+						}
+					}
+				}
+			}
+			else
+			{
+				gridPixelR.push_back(0);
+				gridPixelTheta.push_back(0);
+			}
+		}
+	}
+}

source/model/processor/strategies/Cri.cpp

@@ -0,0 +1,71 @@
+#include "model/processor/strategies/Cri.h"
+#include "model/processor/BIP.h"
+#include <QPixmap>
+#include <QImage>
+
+Cri::Cri(const Context context,const QString kernelPath,const QObject *parent = Q_NULLPTR) :
+    IProcessStrategy(context, kernelPath, "Cri", parent),
+    _kernelFunctor(KernelFunctor<Image2DArray, Image2D, Cri_t>(_kernel))
+{
+    memset(&_kernelParameters, 0, sizeof (Cri_t));
+//    _criBuffer = new Image2D()[CRI_MAX_BUFFER_SIZE];
+}
+
+void Cri::cpuProcess(Input_t params)
+{
+        _kernelParameters.criFilterMode = params.criFilterMode;
+        _kernelParameters.scenariFrameNo = params.scenarioFrameNo;
+        _kernelParameters.frameCntr = params.frameCntr;
+}
+
+void Cri::finalize()
+{
+}
+
+
+Image* Cri::processKernel(Image *frames, Buffer* scratchPad)
+{
+    auto format = frames->getImageInfo<CL_IMAGE_FORMAT>();
+    auto width = frames->getImageInfo<CL_IMAGE_WIDTH>();
+    auto height = frames->getImageInfo<CL_IMAGE_HEIGHT>();
+
+    _criBuffer[_kernelParameters.scenariFrameNo] = static_cast<Image2D*>(frames);
+    int err = 100;
+
+//    Image2DArray bufferframes = Image2DArray(_CLContext, CL_MEM_READ_WRITE,  ImageFormat(format.image_channel_order, format.image_channel_data_type),
+//                                             16,
+//                                             width,
+//                                             height,
+//                                             0,0);
+//    BIP::getInstance()->CLQueue.enqueueWriteImage(*bufferframes, CL_TRUE, array<size_type, 3> {0, 0, 0},
+//                              array<size_type, 4> {width, height, 1},
+//                              width * sizeof (myflt),
+//                              0,
+//                              _criBuffer);
+    auto imgs = new Image2DArray(_CLContext, CL_MEM_READ_WRITE,  ImageFormat(format.image_channel_order, format.image_channel_data_type),
+                           16,
+                           width,
+                           height,
+                           width *4* sizeof (myflt),
+                           0,
+                           _criBuffer,
+                           &err);
+    qDebug()<<"erro is : " << err;
+//    cl::enqueueReadImage()
+
+    auto imageOutput = new Image2D(_CLContext,
+                            CL_MEM_READ_WRITE,
+                            ImageFormat(format.image_channel_order, format.image_channel_data_type),
+                            width,
+                            height);
+    cl::EnqueueArgs eargs(BIP::getInstance()->CLQueue, cl::NDRange(width, height));
+
+    _openCLHelper.runKernelFunctor<Image2DArray, Image2D, Cri_t>(_kernelFunctor,
+                                      eargs,
+                                      *imgs,
+                                      *imageOutput,
+                                      _kernelParameters);
+
+    delete imgs;
+    return imageOutput;
+}

source/model/processor/strategies/DynCont.cpp

@@ -13,23 +13,11 @@ DynCont::DynCont(const Context context,
 	memset(&_kernelParameters, 0, sizeof (DynCont_t));
 }
 
-void DynCont::cpuProcess(ScenGenOutput_t parameters)
+void DynCont::cpuProcess(Input_t parameters)
 {
-	if(parameters.dynContGain.isUpdated)
+		_kernelParameters.gain = parameters.dynContGain;
-	{
+		_kernelParameters.dynContSelector = parameters.dynContSelector;
-		_kernelParameters.gain = parameters.dynContGain.value;
+		_kernelParameters.compressionType = parameters.compressionType;
-	}
-
-	if(parameters.dynContSelector.isUpdated)
-	{
-		_kernelParameters.dynContSelector = parameters.dynContSelector.value;
-	}
-
-
-	if(parameters.compressionType.isUpdated)
-	{
-		_kernelParameters.compressionType = parameters.compressionType.value;
-	}
 }
 
 void DynCont::finalize()

source/model/processor/strategies/Enhance.cpp

@@ -14,12 +14,10 @@ Enhance::Enhance(const Context context,
 	_filter = Q_NULLPTR;
 }
 
-void Enhance::cpuProcess(ScenGenOutput_t parameters)
+void Enhance::cpuProcess(Input_t parameters)
 {
-	if(parameters.enhance.isUpdated || parameters.enhanceAlgorithm.isUpdated)
-	{
 	_run = false;
-		if(parameters.enhance.value == 0)
+	if(parameters.enhance == 0)
 	{
 		return;
 	}
@@ -28,9 +26,9 @@ void Enhance::cpuProcess(ScenGenOutput_t parameters)
 	int *backgroundRecovery;
 
 	//sharpen
-		if(parameters.enhanceAlgorithm.value == 0)
+	if(parameters.enhanceAlgorithm == 0)
 	{
-			auto alpha = 0.25f * (parameters.enhance.value - 1);
+		auto alpha = 0.25f * (parameters.enhance - 1);
 
 		_kernelParameters.filterWidth = 3;
 		_kernelParameters.filterHeight = 3;
@@ -61,7 +59,7 @@ void Enhance::cpuProcess(ScenGenOutput_t parameters)
 		_run = true;
 	}
 	//log
-		else if(parameters.enhanceAlgorithm.value == 1)
+	else if(parameters.enhanceAlgorithm == 1)
 	{
 		_kernelParameters.filterWidth = 5;
 		_kernelParameters.filterHeight = 5;
@@ -69,7 +67,7 @@ void Enhance::cpuProcess(ScenGenOutput_t parameters)
 		hpf = new float[25];
 		backgroundRecovery = new int[25];
 
-			auto sigma = 0.5f + 0.25f * (parameters.enhance.value - 1);
+		auto sigma = 0.5f + 0.25f * (parameters.enhance - 1);
 		float sumHg = 0;
 		float h[25];
 
@@ -118,7 +116,6 @@ void Enhance::cpuProcess(ScenGenOutput_t parameters)
 													   filter);
 		delete[] filter;
 	}
-	}
 }
 
 void Enhance::finalize()

source/model/processor/strategies/GrayMap.cpp

@@ -13,12 +13,9 @@ GrayMap::GrayMap(const Context context,
 	memset(&_kernelParameters, 0, sizeof (GrayMap_t));
 }
 
-void GrayMap::cpuProcess(ScenGenOutput_t parameters)
+void GrayMap::cpuProcess(Input_t parameters)
 {
-	if(parameters.grayMapSelector.isUpdated)
+	_kernelParameters.grayMapSelector = parameters.grayMapSelector;
-	{
-		_kernelParameters.grayMapSelector = parameters.grayMapSelector.value;
-	}
 }
 
 void GrayMap::finalize()

source/model/processor/strategies/Persist.cpp

@@ -15,13 +15,10 @@ Persist::Persist(const Context context,
 	_reCalc = true;
 }
 
-void Persist::cpuProcess(ScenGenOutput_t parameters)
+void Persist::cpuProcess(Input_t parameters)
 {
-	if(parameters.persist.isUpdated)
+	_kernelParameters.persist = parameters.persist;
-	{
-		_kernelParameters.persist = parameters.persist.value;
 	_reCalc = true;
-	}
 }
 
 void Persist::finalize()

source/model/processor/strategies/Rejection.cpp

@@ -12,9 +12,9 @@ Rejection::Rejection(const Context context,
 
 }
 
-void Rejection::cpuProcess(ScenGenOutput_t parameters)
+void Rejection::cpuProcess(Input_t parameters)
 {
-	//_rejectionThr = parameters.rejectThreshold.value;
+	//_rejectionThr = parameters.rejectThreshold;
 }
 
 void Rejection::finalize()

source/model/processor/strategies/ScanConversion.cpp

@@ -2,6 +2,9 @@
 #include <QPixmap>
 #include <QImage>
 #include "model/processor/BIP.h"
+#include "model/algorithms/ScanConversionAlg.h"
+
+#include <QtMath>
 
 ScanConversion::ScanConversion(const Context context,
 							   const QString kernelPath,
@@ -10,385 +13,86 @@ ScanConversion::ScanConversion(const Context context,
 	_kernelFunctor(KernelFunctor<Image2D, Image2D,
 				   Buffer, Buffer, Buffer, Buffer, ScanConversion_t>(_kernel))
 {
-	_gridPixelXPos = Q_NULLPTR;
-	_gridPixelZPos = Q_NULLPTR;
-	_scanXPos = Q_NULLPTR;
-	_scanZPos = Q_NULLPTR;
-
 	_gridX = Q_NULLPTR;
 	_gridZ = Q_NULLPTR;
 	_queryX = Q_NULLPTR;
 	_queryZ = Q_NULLPTR;
-
-	_gridPixelR = Q_NULLPTR;
-	_gridPixelTheta = Q_NULLPTR;
 }
 
-void ScanConversion::cpuProcess(ScenGenOutput_t params)
+void ScanConversion::cpuProcess(Input_t params)
 {
 	auto context = _openCLHelper.getContext();
 	auto queue = BIP::getInstance()->CLQueue;
-	//virtual convex
-	if(params.virtualConvex.value)
-	{
-		if(params.outputWidth.isUpdated|| params.outputHeight.isUpdated)
-		{
-			if(_gridPixelXPos)
-				delete[] _gridPixelXPos;
-
-			if(_gridPixelZPos)
-				delete[] _gridPixelZPos;
-
-			_gridPixelXPos = new myflt[params.outputWidth.value *
-											 params.outputHeight.value];
-			_gridPixelZPos = new myflt[params.outputWidth.value *
-											 params.outputHeight.value];
-
-			_width = params.outputWidth.value;
-			_height = params.outputHeight.value;
-
-			_kernelParameters.width = _width;
-		}
-
-		if(params.depth.isUpdated || params.startDepth.isUpdated ||
-			params.fieldOfView.isUpdated || params.vcMaxTheta.isUpdated ||
-			params.outputWidth.isUpdated || params.outputHeight.isUpdated)
-		{
-			auto maxZ = params.depth.value;
-			auto minZ = params.startDepth.value * cosf(params.vcMaxTheta.value);
-			auto maxX = params.fieldOfView.value / 2 + maxZ * sinf(params.vcMaxTheta.value);
-			auto minX = -1 * maxX;
-
-			auto baseZ = (maxZ - minZ) / (params.outputHeight.value - 1);
-			auto baseX = (maxX - minX) / (params.outputWidth.value - 1);
-
-			for(auto i = 0; i < params.outputHeight.value; i++)
-			{
-				auto temp = i * baseZ;
-				for(auto j = 0; j < params.outputWidth.value; j++)
-				{
-					_gridPixelZPos[i * params.outputHeight.value + j] = minZ + temp;
-					_gridPixelXPos[i * params.outputHeight.value + j] = minX + (baseX * j);
-				}
-			}
-
-			auto virtualOriginZ = params.fieldOfView.value / 2 / tanf(params.vcMaxTheta.value);
-
-			if(_gridPixelR)
-				delete[] _gridPixelR;
-
-			if(_gridPixelTheta)
-				delete[] _gridPixelTheta;
-
-			_gridPixelR = new myflt[params.outputWidth.value *
-											 params.outputHeight.value];
-			_gridPixelTheta = new myflt[params.outputWidth.value *
-											 params.outputHeight.value];
-
-			auto strTan = tanf(params.steering.value);
-
-			for(auto i = 0; i < params.outputWidth.value *
-				params.outputHeight.value; i++)
-			{
-				auto x = _gridPixelXPos[i];
-				auto z = _gridPixelZPos[i];
-
-				auto pixelTheta = atanf(x / (z + virtualOriginZ));
-
-				if(pixelTheta >= -params.vcMaxTheta.value - abs(params.steering.value) &&
-					pixelTheta <= params.vcMaxTheta.value + abs(params.steering.value))
-				{
-					if(params.steering.value == 0)
-					{
-						auto gridPixelAx = sqrtf(powf(x - virtualOriginZ * tanf(pixelTheta), 2) + powf(z, 2));
-						if(gridPixelAx >= params.startDepth.value &&
-							gridPixelAx <= params.depth.value)
-						{
-							_gridPixelR[i] = gridPixelAx;
-							_gridPixelTheta[i] = pixelTheta;
-						}
-						else
-						{
-							_gridPixelR[i] = 0;
-							_gridPixelTheta[i] = 0;
-						}
-					}
-					else
-					{
-						auto a = virtualOriginZ * strTan;
-						auto b = x * strTan + virtualOriginZ + z;
-						auto c = x - z * strTan;
-						auto interceptTheta = atanf((b + sqrtf(powf(b, 2) - 4 * a * c)) / (2 * a));
-						if(interceptTheta > params.vcMaxTheta.value ||
-							interceptTheta < -params.vcMaxTheta.value)
-						{
-							interceptTheta = atanf((b - sqrtf(powf(b, 2) - 4 * a * c)) / (2 * a));
-							if(interceptTheta > params.vcMaxTheta.value ||
-								interceptTheta < -params.vcMaxTheta.value)
-							{
-								_gridPixelR[i] = 0;
-								_gridPixelTheta[i] = 0;
-							}
-							else
-							{
-								auto gridPixelAx = sqrtf(powf(x - virtualOriginZ * tanf(interceptTheta), 2) + powf(z, 2));
-								if(gridPixelAx >= params.startDepth.value &&
-									gridPixelAx <= params.depth.value)
-								{
-									_gridPixelR[i] = gridPixelAx;
-									_gridPixelTheta[i] = interceptTheta;
-								}
-								else
-								{
-									_gridPixelR[i] = 0;
-									_gridPixelTheta[i] = 0;
-								}
-							}
-						}
-						else
-						{
-							auto gridPixelAx = sqrtf(powf(x - virtualOriginZ * tanf(interceptTheta), 2) + powf(z, 2));
-							if(gridPixelAx >= params.startDepth.value &&
-								gridPixelAx <= params.depth.value)
-							{
-								_gridPixelR[i] = gridPixelAx;
-								_gridPixelTheta[i] = interceptTheta;
-							}
-							else
-							{
-								_gridPixelR[i] = 0;
-								_gridPixelTheta[i] = 0;
-							}
-						}
-					}
-				}
-				else
-				{
-					_gridPixelR[i] = 0;
-					_gridPixelTheta[i] = 0;
-				}
-			}
 
 	if(_queryX)
 		delete _queryX;
 
 	if(_queryZ)
 		delete _queryZ;
-			_queryX = _openCLHelper.array2CLBuffer(context,
-												   params.outputWidth.value *
-												   params.outputHeight.value *
-												   sizeof (myflt));
-			_queryZ = _openCLHelper.array2CLBuffer(context,
-												   params.outputWidth.value *
-												   params.outputHeight.value *
-												   sizeof (myflt));
-
-			BIP::getInstance()->CLQueue.enqueueWriteBuffer(*_queryZ, CL_TRUE, 0,
-									   params.outputWidth.value *
-									   params.outputHeight.value *
-									   sizeof (myflt),
-									   _gridPixelR);
-			queue.enqueueWriteBuffer(*_queryX, CL_TRUE, 0,
-									   params.outputWidth.value *
-									   params.outputHeight.value *
-									   sizeof (myflt),
-									   _gridPixelTheta);
-		}
-
-		if(params.minScanAz.isUpdated || params.rxLineNo.isUpdated ||
-				params.rxLineDaz.isUpdated)
-		{
-			if(_scanXPos)
-				delete [] _scanXPos;
 
 	if(_gridX)
 		delete _gridX;
 
-			_scanXPos = new myflt[params.rxLineNo.value];
-			for(auto i = 0; i < params.rxLineNo.value; i++)
-			{
-				_scanXPos[i] = params.minScanAz.value + i * params.rxLineDaz.value;
-			}
-
-			_gridX = _openCLHelper.array2CLBuffer(context,
-												  static_cast<quint64>(params.rxLineNo.value)
-												  * sizeof (myflt));
-
-			queue.enqueueWriteBuffer(*_gridX, CL_TRUE, 0,
-									 static_cast<unsigned long>(params.rxLineNo.value) * sizeof (myflt),
-									 _scanXPos);
-
-			_kernelParameters.gridXSize = params.rxLineNo.value;
-		}
-
-		if(params.rxFocusPointNo.isUpdated || params.minScanAx.isUpdated ||
-				params.rxPointDax.isUpdated)
-		{
-			if(_scanZPos)
-				delete[] _scanZPos;
-
 	if(_gridZ)
 		delete _gridZ;
 
-			_scanZPos = new myflt [params.rxFocusPointNo.value];
+	_gridPixelXPos.clear();
-			for(auto i = 0; i < params.rxFocusPointNo.value; i++)
+	_gridPixelZPos.clear();
-			{
+	_scanXPos.clear();
-				_scanZPos[i] = params.minScanAx.value + i * params.rxPointDax.value;
+	_scanZPos.clear();
-			}
-
-			_gridZ = _openCLHelper.array2CLBuffer(context,
-												  static_cast<quint64>(params.rxFocusPointNo.value)
-												  * sizeof (myflt));
-
-			queue.enqueueWriteBuffer(*_gridZ, CL_TRUE, 0,
-									 static_cast<unsigned long>(params.rxFocusPointNo.value) * sizeof (myflt),
-									 _scanZPos);
-
-			_kernelParameters.gridZSize = params.rxFocusPointNo.value;
-		}
-	}
-	//linear non convex
-	else
-	{
-		if(params.outputWidth.isUpdated || params.outputHeight.isUpdated)
-		{
-			if(_gridPixelXPos)
-				delete[] _gridPixelXPos;
-
-			if(_gridPixelZPos)
-				delete[] _gridPixelZPos;
-
-			_gridPixelXPos = new myflt[params.outputWidth.value *
-											 params.outputHeight.value];
-			_gridPixelZPos = new myflt[params.outputWidth.value *
-											 params.outputHeight.value];
-
-			if(_queryX)
-				delete _queryX;
-
-			if(_queryZ)
-				delete _queryZ;
 
 	_queryX = _openCLHelper.array2CLBuffer(context,
-												   params.outputWidth.value *
+										   params.outputWidth *
-												   params.outputHeight.value *
+										   params.outputHeight *
 										   sizeof (myflt));
 	_queryZ = _openCLHelper.array2CLBuffer(context,
-												   params.outputWidth.value *
+										   params.outputWidth *
-												   params.outputHeight.value *
+										   params.outputHeight *
 										   sizeof (myflt));
 
-			_width = params.outputWidth.value;
+	_gridX = _openCLHelper.array2CLBuffer
-			_height = params.outputHeight.value;
+			(context, static_cast<quint64>(params.rxLineNo * sizeof (float)));
 
-			_kernelParameters.width = _width;
+	_gridZ = _openCLHelper.array2CLBuffer
-		}
+			(context, static_cast<quint64>(params.rxFocusPointNo * sizeof (float)));
 
-		if(params.depth.isUpdated || params.startDepth.isUpdated ||
+	ScanConversionAlg::scanConversion(params, _scanXPos, _scanZPos, _gridPixelXPos, _gridPixelZPos);
-				params.fieldOfView.isUpdated || params.steering.isUpdated ||
-				params.outputWidth.isUpdated || params.outputHeight.isUpdated)
-		{
-			auto maxZ = params.depth.value;
-			auto minZ = params.startDepth.value;
-			auto maxX = params.fieldOfView.value / 2;
-			auto minX = -1 * maxX;
 
-			auto baseZ = (maxZ - minZ) / (params.outputHeight.value - 1);
-			auto baseX = (maxX - minX) / (params.outputWidth.value - 1);
-
-			for(auto i = 0; i < params.outputHeight.value; i++)
-			{
-				auto temp = i * baseZ;
-				auto tan_result = temp * tanf(params.steering.value);
-				for(auto j = 0; j < params.outputWidth.value; j++)
-				{
-					_gridPixelZPos[i * params.outputHeight.value + j] = minZ + temp;
-					_gridPixelXPos[i * params.outputHeight.value + j] = minX + (baseX * j) - tan_result;
-				}
-			}
-
-			BIP::getInstance()->CLQueue.enqueueWriteBuffer(*_queryX, CL_TRUE, 0,
-									   params.outputWidth.value *
-									   params.outputHeight.value *
-									   sizeof (myflt),
-									   _gridPixelXPos);
 	queue.enqueueWriteBuffer(*_queryZ, CL_TRUE, 0,
-									   params.outputWidth.value *
+							 params.outputWidth *
-									   params.outputHeight.value *
+							 params.outputHeight *
 							 sizeof (myflt),
-									   _gridPixelZPos);
+							 _gridPixelZPos.data());
-		}
-
-		if(params.fieldOfView.isUpdated || params.rxLineNo.isUpdated ||
-				params.rxLineDaz.isUpdated)
-		{
-			if(_scanXPos)
-				delete [] _scanXPos;
 
-			if(_gridX)
+	queue.enqueueWriteBuffer(*_queryX, CL_TRUE, 0,
-				delete _gridX;
+							 params.outputWidth *
-
+							 params.outputHeight *
-			_scanXPos = new myflt[params.rxLineNo.value];
+							 sizeof (myflt),
-			for(auto i = 0; i < params.rxLineNo.value; i++)
+							 _gridPixelXPos.data());
-			{
-				_scanXPos[i] = -params.fieldOfView.value / 2 + i * params.rxLineDaz.value;
-			}
-
-			_gridX = _openCLHelper.array2CLBuffer(context,
-												  static_cast<quint64>(params.rxLineNo.value)
-												  * sizeof (myflt));
 
 	queue.enqueueWriteBuffer(*_gridX, CL_TRUE, 0,
-									 static_cast<unsigned long>(params.rxLineNo.value) * sizeof (myflt),
+							 static_cast<quint64>(params.rxLineNo *  sizeof (float)),
-									 _scanXPos);
+							 _scanXPos.data());
-
-			_kernelParameters.gridXSize = params.rxLineNo.value;
-		}
-
-		if(params.rxFocusPointNo.isUpdated || params.rxPointDax.isUpdated)
-		{
-			if(_scanZPos)
-				delete[] _scanZPos;
-
-			if(_gridZ)
-				delete _gridZ;
-
-			_scanZPos = new myflt [params.rxFocusPointNo.value];
-			for(auto i = 0; i < params.rxFocusPointNo.value; i++)
-			{
-				_scanZPos[i] = params.startDepth.value + i * params.rxPointDax.value;
-			}
-
-			_gridZ = _openCLHelper.array2CLBuffer(context,
-												  static_cast<quint64>(params.rxFocusPointNo.value)
-												  * sizeof (myflt));
 
 	queue.enqueueWriteBuffer(*_gridZ, CL_TRUE, 0,
-									 static_cast<unsigned long>(params.rxFocusPointNo.value) * sizeof (myflt),
+							 static_cast<quint64>(params.rxFocusPointNo * sizeof (float)),
-									 _scanZPos);
+							 _scanZPos.data());
+
+	_kernelParameters.gridXSize = params.rxLineNo;
+	_kernelParameters.gridZSize = params.rxFocusPointNo;
+	_kernelParameters.width = params.outputWidth;
 
-			_kernelParameters.gridZSize = params.rxFocusPointNo.value;
+	_width = params.outputWidth;
-		}
+	_height = params.outputHeight;
-	}
 }
 
 void ScanConversion::finalize()
 {
-	delete _gridPixelXPos;
-	delete _gridPixelZPos;
-	delete _scanXPos;
-	delete _scanZPos;
-
 	delete _gridX;
 	delete _gridZ;
 	delete _queryX;
 	delete _queryZ;
 
-	_gridPixelXPos = Q_NULLPTR;
-	_gridPixelZPos = Q_NULLPTR;
-	_scanXPos = Q_NULLPTR;
-	_scanZPos = Q_NULLPTR;
-
 	_gridX = Q_NULLPTR;
 	_gridZ = Q_NULLPTR;
 	_queryX = Q_NULLPTR;

source/model/processor/strategies/Sri.cpp

@@ -13,12 +13,9 @@ Sri::Sri(const Context context,
 	memset(&_kernelParameters, 0, sizeof (Sri_t));
 }
 
-void Sri::cpuProcess(ScenGenOutput_t parameters)
+void Sri::cpuProcess(Input_t parameters)
 {
-	if(parameters.sri.isUpdated)
+	_kernelParameters.sri = parameters.sri;
-	{
-		_kernelParameters.sri = parameters.sri.value;
-	}
 }
 
 void Sri::finalize()

source/model/processor/strategies/TintMap.cpp

@@ -13,12 +13,9 @@ TintMap::TintMap(const Context context,
 	memset(&_kernelParameters, 0, sizeof (TintMap_t));
 }
 
-void TintMap::cpuProcess(ScenGenOutput_t parameters)
+void TintMap::cpuProcess(Input_t parameters)
 {
-	if(parameters.tintMapSelector.isUpdated)
+	_kernelParameters.tintMapSelector = parameters.tintMapSelector;
-	{
-		_kernelParameters.tintMapSelector = parameters.tintMapSelector.value;
-	}
 }
 
 void TintMap::finalize()