void L1opticalFlowforPictures()
{
int i = 0;
opticalFlow.Height = inputImage_1.ImageHeight;
opticalFlow.Width = inputImage_1.ImageWidth;
opticalFlow.Array = new float[2][];
opticalFlow.Array[0] = new float[opticalFlow.Width * opticalFlow.Height];
opticalFlow.Array[1] = new float[opticalFlow.Width * opticalFlow.Height];
sw.Start();
opticalFlow = L1flow.TV_L1_opticalFlow(inputImage_1.Bitmap, inputImage_2.Bitmap, out i);
sw.Stop();
label10.Text = String.Format("Run time: {0} [s]", Convert.ToString(sw.Elapsed.TotalSeconds));
label10.Visible = true;
float[] length = _CLProcessor.calcFlowLength(opticalFlow);
label11.Text = String.Format("Max value: {0} [pixel/frame transition]", Convert.ToString(length.Max()));
OutputImage = _CLProcessor.decorateFlowColor(inputImage_1.Bitmap, opticalFlow, L1flow.flowInterval, L1flow.threshold);
pictureBox3.Image = OutputImage.Bitmap;
sw.Reset();
// label12.Text = String.Format(Convert.ToString(i));
//label11.Visible = true;
//label12.Visible = true;
saveToolStripMenuItem.Enabled = true;
}
private void flowToolStripMenuItem1_Click(object sender, EventArgs e)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
_ImageFileHandler.WriteFlowArrayToFloFile(FlowArray.ExpandForEvaluation(_SingleFlow, _LeftFlowImage.ImageWidth, _LeftFlowImage.ImageHeight), saveFileDialog.FileName);
}
}
private void Button2_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
string Path;
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
Path = ofd.FileName;
groundtruth = fileHandler.convertFloToFlowArray(Path);
}
}
public FlowArray calcOpticalFlow(Bitmap image0, Bitmap image1, out int realiteration)
{
SimpleImage Image0 = new SimpleImage(image0);
SimpleImage Image1 = new SimpleImage(image1);
FlowArray opticalFlow = new FlowArray();
opticalFlow.Height = Image1.ImageHeight;
opticalFlow.Width = Image1.ImageWidth;
opticalFlow.Array = new float[2][];
opticalFlow.Array[0] = new float[opticalFlow.Width * opticalFlow.Height];
opticalFlow.Array[1] = new float[opticalFlow.Width * opticalFlow.Height];
float[][] J = new float[6][];
J[0] = new float[opticalFlow.Width * opticalFlow.Height];
J[1] = new float[opticalFlow.Width * opticalFlow.Height];
J[2] = new float[opticalFlow.Width * opticalFlow.Height];
J[3] = new float[opticalFlow.Width * opticalFlow.Height];
J[4] = new float[opticalFlow.Width * opticalFlow.Height];
float errorValue = threshold;
int i = 0;
if (sigma == 0)
{
while (!((i == iteration)))
{
opticalFlow = calcLocalGlobalOpticalFlow(Image0, Image1, opticalFlow);
i++;
}
}
if (sigma != 0)
{
J = calc_J(Image0, Image1);
J = Gauss_J(J, Image0.ImageWidth, Image0.ImageHeight);
while (!((i == iteration)))
{
opticalFlow = calcLocalGlobalOpticalFlow_withSmoothed_J(J, opticalFlow);
i++;
}
}
realiteration = i;
return(opticalFlow);
}
void HSopticalFlowwithPyramid()
{
sw.Start();
opticalFlow = HornSchunck.HS_pyramidical_opticalFlow(inputImage_1, inputImage_2);
sw.Stop();
label9.Text = String.Format("Run time: {0} [s]", Convert.ToString(sw.Elapsed.TotalSeconds));
label9.Visible = true;
float[] length = _CLProcessor.calcFlowLength(opticalFlow);
label18.Text = String.Format("Max value: {0} [pixel/frame transition]", Convert.ToString(length.Max()));
OutputImage = _CLProcessor.decorateFlowColor(inputImage_1.Bitmap, opticalFlow, HornSchunck.flowInterval, HornSchunck.threshold);
pictureBox3.Image = OutputImage.Bitmap;
sw.Reset();
saveToolStripMenuItem.Enabled = true;
}
private void calcHornSchunck_video()
{
FlowArray opticalFlow = new FlowArray();
opticalFlow.Height = input1bitmap.Height;
opticalFlow.Width = input1bitmap.Width;
opticalFlow.Array = new float[2][];
opticalFlow.Array[0] = new float[opticalFlow.Width * opticalFlow.Height];
opticalFlow.Array[1] = new float[opticalFlow.Width * opticalFlow.Height];
if (videoSelected)
{
while (!(image.Empty()))
{
input1bitmap = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(image);
sw.Start();
for (int i = 0; i < 1; i++)
{
opticalFlow = HornSchunck.calculateOpticalFlow(input1bitmap, input2bitmap, out int k, opticalFlow);
}
OutputVideo = _CLProcessor.decorateFlowColor(input1bitmap, opticalFlow, HornSchunck.flowInterval, HornSchunck.threshold);
pictureBox4.Image.Dispose();
pictureBox5.Image.Dispose();
pictureBox4.Image = OutputVideo.Bitmap;
pictureBox5.Image = input1bitmap;
Application.DoEvents();
pictureBox4.Refresh();
pictureBox5.Refresh();
sw.Stop();
runTime = 1 / (float)sw.Elapsed.TotalSeconds;
label9.Text = String.Format("Frame rate: {0} [fps]", Convert.ToString(runTime));
label9.Visible = true;
sw.Reset();
input2bitmap = input1bitmap;
capture.Read(image);
}
}
videoSelected = false;
capture.Dispose();
image.Dispose();
pictureBox4.Image.Dispose();
pictureBox5.Image.Dispose();
}
void LGopticalFlowforPictures()
{
int i = 0;
sw.Start();
opticalFlow = LGflow.calcOpticalFlow(inputImage_1.Bitmap, inputImage_2.Bitmap, out i);
sw.Stop();
label9.Text = String.Format("Run time: {0} [s]", Convert.ToString(sw.Elapsed.TotalSeconds));
label9.Visible = true;
float[] length = _CLProcessor.calcFlowLength(opticalFlow);
label17.Text = String.Format("Max value: {0} [pixel/frame transition]", Convert.ToString(length.Max()));
OutputImage = _CLProcessor.decorateFlowColor(inputImage_1.Bitmap, opticalFlow, LGflow.flowInterval, LGflow.threshold);
pictureBox3.Image = OutputImage.Bitmap;
sw.Reset();
saveToolStripMenuItem.Enabled = true;
}
private void CalcOpticalFlowBase(Bitmap leftInput, Bitmap rightInput, Func <SimpleImage, SimpleImage, int, FlowArray> flowCalcFunc, int pyramidLevel = 4)
{
SimpleImage left = new SimpleImage(leftInput);
SimpleImage right = new SimpleImage(rightInput);
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
_SingleFlow = flowCalcFunc(left, right, pyramidLevel);
watch.Stop();
this.CalculationTimeText.Text = watch.Elapsed.Milliseconds.ToString();
SimpleImage demonstrator = _CLProcessor.ModifyImageWithFlow(left, null, _SingleFlow);
_LeftFlowImage = left;
_RightFlowImage = right;
_DIsplayedImage = _LeftFlowImage;
_ModifiedImage = demonstrator;
}
public FlowArray LG_pyramidical_opticalFlow(SimpleImage Image0, SimpleImage Image1)
{
SimpleImage[][] pyramids = cLProcessor.CreatePyramids(Image0, Image1, pyramidLevel);
SimpleImage[] leftPyramid = pyramids[0];
SimpleImage[] rightPyramid = pyramids[1];
FlowArray[] flows = new FlowArray[pyramidLevel];
flows[pyramidLevel - 1] = calcOpticalFlow(leftPyramid[pyramidLevel - 1].Bitmap, rightPyramid[pyramidLevel - 1].Bitmap, out int k);
SimpleImage warpImage = new SimpleImage();
for (int i = 1; i < pyramidLevel; i++)
{
flows[pyramidLevel - (i + 1)] = FlowArray.Expand(flows[pyramidLevel - i], leftPyramid[pyramidLevel - (i + 1)].ImageWidth, leftPyramid[pyramidLevel - (i + 1)].ImageHeight);
warpImage = cLProcessor.pushImagewithFlow(leftPyramid[pyramidLevel - (i + 1)], flows[pyramidLevel - (i + 1)]);
FlowArray correction = calcOpticalFlow(warpImage.Bitmap, rightPyramid[pyramidLevel - (i + 1)].Bitmap, out k);
flows[pyramidLevel - (i + 1)] = flows[pyramidLevel - (i + 1)] + correction;
}
return(flows[0]);
}
private void calcL1_video()
{
if (videoSelected)
{
while (!(image.Empty()))
{
input1bitmap = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(image);
sw.Start();
opticalFlow = L1flow.TV_L1_opticalFlow(input1bitmap, input2bitmap, out int k);
OutputVideo = _CLProcessor.decorateFlowColor(input1bitmap, opticalFlow, L1flow.flowInterval, L1flow.threshold);
pictureBox4.Image.Dispose();
pictureBox5.Image.Dispose();
pictureBox4.Image = OutputVideo.Bitmap;
pictureBox5.Image = input1bitmap;
Application.DoEvents();
pictureBox4.Refresh();
pictureBox5.Refresh();
sw.Stop();
runTime = 1 / (float)sw.Elapsed.TotalSeconds;
label10.Text = String.Format("Frame rate: {0} [fps]", Convert.ToString(runTime));
label10.Visible = true;
sw.Reset();
input2bitmap = input1bitmap;
capture.Read(image);
}
}
videoSelected = false;
capture.Dispose();
image.Dispose();
pictureBox4.Image.Dispose();
pictureBox5.Image.Dispose();
}
private void playVideowithSaving()
{
Mat save = new Mat();
FileDialog ofd = new SaveFileDialog();
string imagePath;
OpenCvSharp.FourCC codec = OpenCvSharp.FourCC.Default;
OpenCvSharp.CvSize size;
size.Height = input1bitmap.Height;
size.Width = input1bitmap.Width;
FlowArray opticalFlow = new FlowArray();
opticalFlow.Height = input1bitmap.Height;
opticalFlow.Width = input1bitmap.Width;
opticalFlow.Array = new float[2][];
opticalFlow.Array[0] = new float[opticalFlow.Width * opticalFlow.Height];
opticalFlow.Array[1] = new float[opticalFlow.Width * opticalFlow.Height];
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
imagePath = ofd.FileName;
videofilename = String.Format("{0}.avi", imagePath);
}
VideoWriter savevid = new VideoWriter();
savevid.Open(videofilename, codec, 24, size, true);
if (videoSelected)
{
while (!(image.Empty()))
{
input1bitmap = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(image);
sw.Start();
for (int i = 0; i < 1; i++)
{
opticalFlow = HornSchunck.calculateOpticalFlow(input1bitmap, input2bitmap, out int k, opticalFlow);
}
OutputVideo = _CLProcessor.decorateFlowColor(input1bitmap, opticalFlow, HornSchunck.flowInterval, HornSchunck.threshold);
save = OpenCvSharp.Extensions.BitmapConverter.ToMat(OutputVideo.Bitmap);
savevid.Write(save);
pictureBox4.Image.Dispose();
pictureBox5.Image.Dispose();
pictureBox4.Image = OutputVideo.Bitmap;
pictureBox5.Image = input1bitmap;
Application.DoEvents();
pictureBox4.Refresh();
pictureBox5.Refresh();
sw.Stop();
runTime = 1 / (float)sw.Elapsed.TotalSeconds;
label9.Text = String.Format("Frame rate: {0} [fps]", Convert.ToString(runTime));
label9.Visible = true;
sw.Reset();
input2bitmap = input1bitmap;
capture.Read(image);
}
}
videoSelected = false;
capture.Dispose();
image.Dispose();
savevid.Release();
//savevid.Dispose();
pictureBox4.Image.Dispose();
pictureBox5.Image.Dispose();
}
public FlowArray calculateOpticalFlow(Bitmap image0, Bitmap image1, out int realIteration, FlowArray opticalFlow)
{
SimpleImage inputImage_1 = new SimpleImage(image0);
SimpleImage inputImage_2 = new SimpleImage(image1);
opticalFlow = new FlowArray();
FlowArray opticalFlowNext = new FlowArray();
FlowArray finalFlow = new FlowArray();
FlowArray medFlow = new FlowArray();
FlowArray tempFlow = new FlowArray();
FlowArray flowError = new FlowArray();
SimpleImage Id = new SimpleImage();
if (opticalFlow == null)
{
opticalFlow = new FlowArray();
opticalFlow.Height = inputImage_1.ImageHeight;
opticalFlow.Width = inputImage_1.ImageWidth;
opticalFlow.Array = new float[2][];
opticalFlow.Array[0] = new float[opticalFlow.Width * opticalFlow.Height];
opticalFlow.Array[1] = new float[opticalFlow.Width * opticalFlow.Height];
}
opticalFlowNext = opticalFlow;
opticalFlowNext.Height = inputImage_1.ImageHeight;
opticalFlowNext.Width = inputImage_1.ImageWidth;
opticalFlowNext.Array = new float[2][];
opticalFlowNext.Array[0] = new float[opticalFlowNext.Width * opticalFlowNext.Height];
opticalFlowNext.Array[1] = new float[opticalFlowNext.Width * opticalFlowNext.Height];
tempFlow.Array = new float[2][];
tempFlow.Height = inputImage_1.ImageHeight;
tempFlow.Width = inputImage_1.ImageWidth;
tempFlow.Array[0] = new float[medFlow.Width * medFlow.Height];
tempFlow.Array[1] = new float[medFlow.Width * medFlow.Height];
flowError.Array = new float[1][];
flowError.Height = inputImage_1.ImageHeight;
flowError.Width = inputImage_1.ImageWidth;
flowError.Array[0] = new float[flowError.Width * flowError.Height];
float thresholdin = eps * eps;
float errorValue = thresholdin;
int i = 0;
//if (pyramidOn == 1)
//{
//while (!((i == maxIteration) || (thresholdin > errorValue)))
while (!((i == maxIteration)))
{
tempFlow = opticalFlow;
opticalFlow = HS_OpticalFlow(inputImage_1.Bitmap, inputImage_2.Bitmap, opticalFlow, alpha);
//float [] error= cLProcessor.calcFlowDist(opticalFlow, tempFlow);
// errorValue = (error.Average());
// Console.WriteLine(errorValue);
i++;
}
realIteration = i;
return(opticalFlow);
}
private FlowArray HS_OpticalFlow(Bitmap input1, Bitmap input2, FlowArray inputFlow, float alpha)
{
SimpleImage left = new SimpleImage(input1);
SimpleImage right = new SimpleImage(input2);
try
{
if (left.ImageHeight != right.ImageHeight || left.ImageWidth != right.ImageWidth)
{
throw (new ArgumentException("The size of the left and right images are not the same!"));
}
ErrorCode error;
FlowArray resultFlowArray = new FlowArray();
resultFlowArray.Array = new float[2][];
resultFlowArray.Width = input1.Width;
resultFlowArray.Height = input1.Height;
resultFlowArray.Array[0] = new float[resultFlowArray.Width * resultFlowArray.Height];
resultFlowArray.Array[1] = new float[resultFlowArray.Width * resultFlowArray.Height];
Kernel flowKernel = Cl.CreateKernel(program, "hornSchunck", out error);
Mem leftImageMemObject = (Mem)Cl.CreateImage2D(context, MemFlags.ReadOnly | MemFlags.CopyHostPtr, SimpleImage.clImageFormat, (IntPtr)left.ImageWidth, (IntPtr)left.ImageHeight, (IntPtr)0, left.ByteArray, out error);
Mem rightImageMemObject = (Mem)Cl.CreateImage2D(context, MemFlags.ReadOnly | MemFlags.CopyHostPtr, SimpleImage.clImageFormat, (IntPtr)right.ImageWidth, (IntPtr)right.ImageHeight, (IntPtr)0, right.ByteArray, out error);
IMem <float> uInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inputFlow.Width * inputFlow.Height * sizeof(float), out error);
IMem <float> vInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inputFlow.Width * inputFlow.Height * sizeof(float), out error);
IMem <float> uOutputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, resultFlowArray.Width * resultFlowArray.Height * sizeof(float), out error);
IMem <float> vOutputlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, resultFlowArray.Width * resultFlowArray.Height * sizeof(float), out error);
error = Cl.SetKernelArg(flowKernel, 0, leftImageMemObject);
error |= Cl.SetKernelArg(flowKernel, 1, rightImageMemObject);
error |= Cl.SetKernelArg <float>(flowKernel, 2, uInputFlowMemObject);
error |= Cl.SetKernelArg <float>(flowKernel, 3, vInputFlowMemObject);
error |= Cl.SetKernelArg <float>(flowKernel, 4, uOutputFlowMemObject);
error |= Cl.SetKernelArg <float>(flowKernel, 5, vOutputlowMemObject);
error |= Cl.SetKernelArg <float>(flowKernel, 6, alpha);
error |= Cl.SetKernelArg <float>(flowKernel, 7, threshold);
error |= Cl.SetKernelArg(flowKernel, 8, inputFlow.Width);
error |= Cl.SetKernelArg(flowKernel, 9, inputFlow.Height);
Event clEvent;
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)left.ImageWidth, (IntPtr)left.ImageHeight, (IntPtr)1 };
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)(inputFlow.Height * inputFlow.Width) };
error = Cl.EnqueueWriteImage(commandQueue, leftImageMemObject, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, left.ByteArray, 0, null, out clEvent);
error = Cl.EnqueueWriteImage(commandQueue, rightImageMemObject, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, right.ByteArray, 0, null, out clEvent);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, uInputFlowMemObject, Bool.True, inputFlow.Array[0], 0, null, out clEvent);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, vInputFlowMemObject, Bool.True, inputFlow.Array[1], 0, null, out clEvent);
// Enqueueing the kernel
error = Cl.EnqueueNDRangeKernel(commandQueue, flowKernel, 1, null, workGroupSizePtr, null, 0, null, out clEvent);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, uOutputFlowMemObject, Bool.True, 0, (resultFlowArray.Width * resultFlowArray.Height), resultFlowArray.Array[0], 0, null, out clEvent);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, vOutputlowMemObject, Bool.True, 0, (resultFlowArray.Width * resultFlowArray.Height), resultFlowArray.Array[1], 0, null, out clEvent);
error = Cl.Finish(commandQueue);
Cl.ReleaseMemObject(leftImageMemObject);
Cl.ReleaseMemObject(rightImageMemObject);
Cl.ReleaseMemObject(uInputFlowMemObject);
Cl.ReleaseMemObject(vInputFlowMemObject);
Cl.ReleaseMemObject(uOutputFlowMemObject);
Cl.ReleaseMemObject(vOutputlowMemObject);
Cl.ReleaseKernel(flowKernel);
return(resultFlowArray);
}
catch (Exception e)
{
throw (new Exception("Flow calculation error", e));
}
}
public float[][] calc_grad_rho_c(SimpleImage I0, SimpleImage I1d, FlowArray Flow)
{
float[][] arrays = new float[4][];
arrays[0] = new float[I0.ImageHeight * I0.ImageWidth];
arrays[1] = new float[I0.ImageHeight * I0.ImageWidth];
arrays[2] = new float[I0.ImageHeight * I0.ImageWidth];
arrays[3] = new float[I0.ImageHeight * I0.ImageWidth];
Mem leftImageMemObject = (Mem)Cl.CreateImage2D(context, MemFlags.ReadOnly | MemFlags.CopyHostPtr, SimpleImage.clImageFormat, (IntPtr)I0.ImageWidth, (IntPtr)I0.ImageHeight, (IntPtr)0, I0.ByteArray, out error);
Mem rightImageMemObject = (Mem)Cl.CreateImage2D(context, MemFlags.ReadOnly | MemFlags.CopyHostPtr, SimpleImage.clImageFormat, (IntPtr)I1d.ImageWidth, (IntPtr)I1d.ImageHeight, (IntPtr)0, I1d.ByteArray, out error);
IMem <float> uInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> vInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> gradXBuf = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, Flow.Height * Flow.Width * sizeof(float), out error);
IMem <float> gradYBuf = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, Flow.Height * Flow.Width * sizeof(float), out error);
IMem <float> grad_2Buf = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, Flow.Height * Flow.Width * sizeof(float), out error);
IMem <float> rho_cBuf = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, Flow.Height * Flow.Width * sizeof(float), out error);
Kernel _Kernel = Cl.CreateKernel(program, "gradRho", out error);
error |= Cl.SetKernelArg(_Kernel, 0, leftImageMemObject);
error |= Cl.SetKernelArg(_Kernel, 1, rightImageMemObject);
error |= Cl.SetKernelArg <float>(_Kernel, 2, uInputFlowMemObject);
error |= Cl.SetKernelArg <float>(_Kernel, 3, vInputFlowMemObject);
error |= Cl.SetKernelArg <float>(_Kernel, 4, gradXBuf);
error |= Cl.SetKernelArg <float>(_Kernel, 5, gradYBuf);
error |= Cl.SetKernelArg <float>(_Kernel, 6, grad_2Buf);
error |= Cl.SetKernelArg <float>(_Kernel, 7, rho_cBuf);
error |= Cl.SetKernelArg(_Kernel, 8, I0.ImageWidth);
error |= Cl.SetKernelArg(_Kernel, 9, I0.ImageHeight);
Event _event;
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)I0.ImageWidth, (IntPtr)I0.ImageHeight, (IntPtr)1 };
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)(Flow.Height * Flow.Width) };
error = Cl.EnqueueWriteImage(commandQueue, leftImageMemObject, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, I0.ByteArray, 0, null, out _event);
error = Cl.EnqueueWriteImage(commandQueue, rightImageMemObject, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, I1d.ByteArray, 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, uInputFlowMemObject, Bool.True, Flow.Array[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, vInputFlowMemObject, Bool.True, Flow.Array[1], 0, null, out _event);
error = Cl.EnqueueNDRangeKernel(commandQueue, _Kernel, 1, null, workGroupSizePtr, null, 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, gradXBuf, Bool.True, 0, (Flow.Width * Flow.Height), arrays[0], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, gradYBuf, Bool.True, 0, (Flow.Width * Flow.Height), arrays[1], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, grad_2Buf, Bool.True, 0, (Flow.Width * Flow.Height), arrays[2], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, rho_cBuf, Bool.True, 0, (Flow.Width * Flow.Height), arrays[3], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.ReleaseMemObject(uInputFlowMemObject);
Cl.ReleaseMemObject(vInputFlowMemObject);
Cl.ReleaseMemObject(leftImageMemObject);
Cl.ReleaseMemObject(rightImageMemObject);
Cl.ReleaseMemObject(gradXBuf);
Cl.ReleaseMemObject(gradYBuf);
Cl.ReleaseMemObject(grad_2Buf);
Cl.ReleaseMemObject(rho_cBuf);
Cl.ReleaseKernel(_Kernel);
return(arrays);
}
public FlowArray TV_L1_opticalFlow(Bitmap image0, Bitmap image1, out int realIteration)
{
SimpleImage Image0 = new SimpleImage(image0);
SimpleImage Image1 = new SimpleImage(image1);
float[][] flowDatas = new float[4][];
SimpleImage Id = new SimpleImage();
FlowArray opticalFlow = new FlowArray();
FlowArray P1 = new FlowArray();
FlowArray P2 = new FlowArray();
opticalFlow.Height = Image1.ImageHeight;
opticalFlow.Width = Image1.ImageWidth;
opticalFlow.Array = new float[2][];
opticalFlow.Array[0] = new float[opticalFlow.Width * opticalFlow.Height];
opticalFlow.Array[1] = new float[opticalFlow.Width * opticalFlow.Height];
P1.Height = Image1.ImageHeight;
P1.Width = Image1.ImageWidth;
P1.Array = new float[2][];
P1.Array[0] = new float[P1.Width * P1.Height];
P1.Array[1] = new float[P1.Width * P1.Height];
P2.Height = Image1.ImageHeight;
P2.Width = Image1.ImageWidth;
P2.Array = new float[2][];
P2.Array[0] = new float[P2.Width * P2.Height];
P2.Array[1] = new float[P2.Width * P2.Height];
FlowArray[] P = new FlowArray[2];
int i = 0;
Id = Image0;
for (int j = 0; j < warps; j++)
{
if (warps > 1)
{
// Id = cLProcessor.pushImagewithFlow(Image0, opticalFlow);
}
flowDatas = calc_grad_rho_c(Id, Image1, opticalFlow);
float[] I1dx = flowDatas[0];
float[] I1dy = flowDatas[1];
float[] grad_2 = flowDatas[2];
float[] rho_c = flowDatas[3];
float thresholdin = this.epsilon * this.epsilon;
float errorValue = threshold;
while (!((i == this.maxiter)))
{
opticalFlow = calc_divP_Flow(flowDatas[0], flowDatas[1], flowDatas[2], flowDatas[3], opticalFlow, P1, P2);
P = calc_P_field(opticalFlow, P1, P2);
P1 = P[0];
P2 = P[1];
i++;
}
}
realIteration = i;
return(opticalFlow);
}
public FlowArray[] calc_P_field(FlowArray Flow, FlowArray P1, FlowArray P2)
{
ErrorCode error;
FlowArray outputFlow1 = new FlowArray();
outputFlow1.Array = new float[2][];
outputFlow1.Width = P1.Width;
outputFlow1.Height = P1.Height;
outputFlow1.Array[0] = new float[outputFlow1.Width * outputFlow1.Height];
outputFlow1.Array[1] = new float[outputFlow1.Width * outputFlow1.Height];
FlowArray outputFlow2 = new FlowArray();
outputFlow2.Array = new float[2][];
outputFlow2.Width = P2.Width;
outputFlow2.Height = P2.Height;
outputFlow2.Array[0] = new float[outputFlow2.Width * outputFlow2.Height];
outputFlow2.Array[1] = new float[outputFlow2.Width * outputFlow2.Height];
IMem <float> uInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> vInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> P11_input = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, P1.Width * P1.Height * sizeof(float), out error);
IMem <float> P12_input = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, P1.Width * P1.Height * sizeof(float), out error);
IMem <float> P21_input = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, P2.Width * P2.Height * sizeof(float), out error);
IMem <float> P22_input = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, P2.Width * P2.Height * sizeof(float), out error);
IMem <float> P11_output = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, outputFlow1.Width * outputFlow1.Height * sizeof(float), out error);
IMem <float> P12_output = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, outputFlow1.Width * outputFlow1.Height * sizeof(float), out error);
IMem <float> P21_output = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, outputFlow2.Width * outputFlow2.Height * sizeof(float), out error);
IMem <float> P22_output = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, outputFlow2.Width * outputFlow2.Height * sizeof(float), out error);
Kernel _Kernel = Cl.CreateKernel(program, "calcP", out error);
error |= Cl.SetKernelArg <float>(_Kernel, 0, uInputFlowMemObject);
error |= Cl.SetKernelArg <float>(_Kernel, 1, vInputFlowMemObject);
error |= Cl.SetKernelArg <float>(_Kernel, 2, this.tau);
error |= Cl.SetKernelArg <float>(_Kernel, 3, this.theta);
error |= Cl.SetKernelArg <float>(_Kernel, 4, P11_input);
error |= Cl.SetKernelArg <float>(_Kernel, 5, P12_input);
error |= Cl.SetKernelArg <float>(_Kernel, 6, P21_input);
error |= Cl.SetKernelArg <float>(_Kernel, 7, P22_input);
error |= Cl.SetKernelArg <float>(_Kernel, 8, P11_output);
error |= Cl.SetKernelArg <float>(_Kernel, 9, P12_output);
error |= Cl.SetKernelArg <float>(_Kernel, 10, P21_output);
error |= Cl.SetKernelArg <float>(_Kernel, 11, P22_output);
error |= Cl.SetKernelArg(_Kernel, 12, Flow.Width);
error |= Cl.SetKernelArg(_Kernel, 13, Flow.Height);
Event _event;
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)(outputFlow1.Height * outputFlow1.Width) };
error = Cl.EnqueueWriteBuffer <float>(commandQueue, uInputFlowMemObject, Bool.True, Flow.Array[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, vInputFlowMemObject, Bool.True, Flow.Array[1], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, P11_input, Bool.True, P1.Array[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, P12_input, Bool.True, P1.Array[1], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, P21_input, Bool.True, P2.Array[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, P22_input, Bool.True, P2.Array[1], 0, null, out _event);
error = Cl.EnqueueNDRangeKernel(commandQueue, _Kernel, 1, null, workGroupSizePtr, null, 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, P11_output, Bool.True, 0, (outputFlow1.Width * outputFlow1.Height), outputFlow1.Array[0], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, P12_output, Bool.True, 0, (outputFlow1.Width * outputFlow1.Height), outputFlow1.Array[1], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, P21_output, Bool.True, 0, (outputFlow2.Width * outputFlow2.Height), outputFlow2.Array[0], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, P22_output, Bool.True, 0, (outputFlow2.Width * outputFlow2.Height), outputFlow2.Array[1], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.ReleaseMemObject(uInputFlowMemObject);
Cl.ReleaseMemObject(vInputFlowMemObject);
Cl.ReleaseMemObject(P11_input);
Cl.ReleaseMemObject(P12_input);
Cl.ReleaseMemObject(P21_input);
Cl.ReleaseMemObject(P22_input);
Cl.ReleaseMemObject(P11_output);
Cl.ReleaseMemObject(P12_output);
Cl.ReleaseMemObject(P21_output);
Cl.ReleaseMemObject(P22_output);
Cl.ReleaseKernel(_Kernel);
FlowArray[] OutputFlows = new FlowArray[2];
OutputFlows[0] = outputFlow1;
OutputFlows[1] = outputFlow2;
return(OutputFlows);
}
public FlowArray calc_divP_Flow(float[] Idx, float[] Idy, float[] grad_2, float[] rho_c, FlowArray inFlow, FlowArray P1, FlowArray P2)
{
FlowArray outFlow = new FlowArray();
outFlow.Array = new float[2][];
outFlow.Width = inFlow.Width;
outFlow.Height = inFlow.Height;
outFlow.Array[0] = new float[outFlow.Width * outFlow.Height];
outFlow.Array[1] = new float[outFlow.Width * outFlow.Height];
IMem <float> grad_2Buf = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> rho_cBuf = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> IdxBuf = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> IdyBuf = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> InFlow_U = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> InFlow_V = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> divP11 = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> divP12 = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> divP21 = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> divP22 = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, inFlow.Width * inFlow.Height * sizeof(float), out error);
IMem <float> OutFlow_U = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, inFlow.Height * inFlow.Width * sizeof(float), out error);
IMem <float> OutFlow_V = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, inFlow.Height * inFlow.Width * sizeof(float), out error);
Kernel _Kernel = Cl.CreateKernel(program, "divP_Flow", out error);
error |= Cl.SetKernelArg(_Kernel, 0, rho_cBuf);
error |= Cl.SetKernelArg(_Kernel, 1, IdxBuf);
error |= Cl.SetKernelArg <float>(_Kernel, 2, IdyBuf);
error |= Cl.SetKernelArg <float>(_Kernel, 3, InFlow_U);
error |= Cl.SetKernelArg <float>(_Kernel, 4, InFlow_V);
error |= Cl.SetKernelArg <float>(_Kernel, 5, OutFlow_U);
error |= Cl.SetKernelArg <float>(_Kernel, 6, OutFlow_V);
error |= Cl.SetKernelArg <float>(_Kernel, 7, this.theta);
error |= Cl.SetKernelArg <float>(_Kernel, 8, this.lambda);
error |= Cl.SetKernelArg <float>(_Kernel, 9, grad_2Buf);
error |= Cl.SetKernelArg <float>(_Kernel, 10, divP11);
error |= Cl.SetKernelArg <float>(_Kernel, 11, divP12);
error |= Cl.SetKernelArg <float>(_Kernel, 12, divP21);
error |= Cl.SetKernelArg <float>(_Kernel, 13, divP22);
error |= Cl.SetKernelArg <float>(_Kernel, 14, threshold);
error |= Cl.SetKernelArg(_Kernel, 15, inFlow.Width);
error |= Cl.SetKernelArg(_Kernel, 16, inFlow.Height);
Event _event;
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)(inFlow.Height * inFlow.Width) };
error = Cl.EnqueueWriteBuffer <float>(commandQueue, rho_cBuf, Bool.True, rho_c, 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, IdxBuf, Bool.True, Idx, 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, IdyBuf, Bool.True, Idy, 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, grad_2Buf, Bool.True, grad_2, 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, InFlow_U, Bool.True, inFlow.Array[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, InFlow_V, Bool.True, inFlow.Array[1], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, divP11, Bool.True, P1.Array[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, divP12, Bool.True, P1.Array[1], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, divP21, Bool.True, P2.Array[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, divP22, Bool.True, P2.Array[1], 0, null, out _event);
error = Cl.EnqueueNDRangeKernel(commandQueue, _Kernel, 1, null, workGroupSizePtr, null, 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, OutFlow_U, Bool.True, 0, (outFlow.Width * outFlow.Height), outFlow.Array[0], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, OutFlow_V, Bool.True, 0, (outFlow.Width * outFlow.Height), outFlow.Array[1], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.ReleaseMemObject(grad_2Buf);
Cl.ReleaseMemObject(rho_cBuf);
Cl.ReleaseMemObject(IdxBuf);
Cl.ReleaseMemObject(IdyBuf);
Cl.ReleaseMemObject(InFlow_U);
Cl.ReleaseMemObject(InFlow_V);
Cl.ReleaseMemObject(divP11);
Cl.ReleaseMemObject(divP12);
Cl.ReleaseMemObject(divP21);
Cl.ReleaseMemObject(divP22);
Cl.ReleaseMemObject(OutFlow_U);
Cl.ReleaseMemObject(OutFlow_V);
Cl.ReleaseKernel(_Kernel);
return(outFlow);
}
private FlowArray calcLocalGlobalOpticalFlow_withSmoothed_J(float[][] J, FlowArray Flow)
{
FlowArray resultFlowArray = new FlowArray();
resultFlowArray.Array = new float[2][];
resultFlowArray.Width = Flow.Width;
resultFlowArray.Height = Flow.Height;
resultFlowArray.Array[0] = new float[resultFlowArray.Width * resultFlowArray.Height];
resultFlowArray.Array[1] = new float[resultFlowArray.Width * resultFlowArray.Height];
IMem <float> uInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> vInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> J1in = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> J2in = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> J3in = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> J4in = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> J5in = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> J6in = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> OutFlow_U = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, Flow.Height * Flow.Width * sizeof(float), out error);
IMem <float> OutFlow_V = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, Flow.Height * Flow.Width * sizeof(float), out error);
Kernel currentKernel = Cl.CreateKernel(program, "localGlobalFlow3", out error);
// Kernel arguiment declaration
error |= Cl.SetKernelArg <float>(currentKernel, 0, J1in);
error |= Cl.SetKernelArg <float>(currentKernel, 1, J2in);
error |= Cl.SetKernelArg <float>(currentKernel, 2, J3in);
error |= Cl.SetKernelArg <float>(currentKernel, 3, J4in);
error |= Cl.SetKernelArg <float>(currentKernel, 4, J5in);
error |= Cl.SetKernelArg <float>(currentKernel, 5, J6in);
error |= Cl.SetKernelArg <float>(currentKernel, 6, uInputFlowMemObject);
error |= Cl.SetKernelArg <float>(currentKernel, 7, vInputFlowMemObject);
error |= Cl.SetKernelArg <float>(currentKernel, 8, OutFlow_U);
error |= Cl.SetKernelArg <float>(currentKernel, 9, OutFlow_V);
error |= Cl.SetKernelArg <float>(currentKernel, 10, alpha);
error |= Cl.SetKernelArg <float>(currentKernel, 11, threshold);
error |= Cl.SetKernelArg(currentKernel, 12, Flow.Width);
error |= Cl.SetKernelArg(currentKernel, 13, Flow.Height);
Event _event;
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)(Flow.Height * Flow.Width) };
error = Cl.EnqueueWriteBuffer <float>(commandQueue, uInputFlowMemObject, Bool.True, Flow.Array[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, vInputFlowMemObject, Bool.True, Flow.Array[1], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, J1in, Bool.True, J[0], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, J2in, Bool.True, J[1], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, J3in, Bool.True, J[2], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, J4in, Bool.True, J[3], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, J5in, Bool.True, J[4], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, J6in, Bool.True, J[5], 0, null, out _event);
error = Cl.EnqueueNDRangeKernel(commandQueue, currentKernel, 1, null, workGroupSizePtr, null, 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, OutFlow_U, Bool.True, 0, (resultFlowArray.Width * resultFlowArray.Height), resultFlowArray.Array[0], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, OutFlow_V, Bool.True, 0, (resultFlowArray.Width * resultFlowArray.Height), resultFlowArray.Array[1], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.ReleaseMemObject(uInputFlowMemObject);
Cl.ReleaseMemObject(vInputFlowMemObject);
Cl.ReleaseMemObject(J1in);
Cl.ReleaseMemObject(J2in);
Cl.ReleaseMemObject(J3in);
Cl.ReleaseMemObject(J4in);
Cl.ReleaseMemObject(J5in);
Cl.ReleaseMemObject(J6in);
Cl.ReleaseMemObject(OutFlow_U);
Cl.ReleaseMemObject(OutFlow_V);
Cl.ReleaseKernel(currentKernel);
return(resultFlowArray);
}
private FlowArray calcLocalGlobalOpticalFlow(SimpleImage Image0, SimpleImage Image1, FlowArray Flow)
{
FlowArray resultFlowArray = new FlowArray();
resultFlowArray.Array = new float[2][];
resultFlowArray.Width = Flow.Width;
resultFlowArray.Height = Flow.Height;
resultFlowArray.Array[0] = new float[resultFlowArray.Width * resultFlowArray.Height];
resultFlowArray.Array[1] = new float[resultFlowArray.Width * resultFlowArray.Height];
Mem leftImageMemObject = (Mem)Cl.CreateImage2D(context, MemFlags.ReadOnly | MemFlags.CopyHostPtr, SimpleImage.clImageFormat, (IntPtr)Image0.ImageWidth, (IntPtr)Image0.ImageHeight, (IntPtr)0, Image0.ByteArray, out error);
Mem rightImageMemObject = (Mem)Cl.CreateImage2D(context, MemFlags.ReadOnly | MemFlags.CopyHostPtr, SimpleImage.clImageFormat, (IntPtr)Image1.ImageWidth, (IntPtr)Image1.ImageHeight, (IntPtr)0, Image1.ByteArray, out error);
IMem <float> uInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> vInputFlowMemObject = Cl.CreateBuffer <float>(context, MemFlags.ReadOnly, Flow.Width * Flow.Height * sizeof(float), out error);
IMem <float> OutFlow_U = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, Flow.Height * Flow.Width * sizeof(float), out error);
IMem <float> OutFlow_V = Cl.CreateBuffer <float>(context, MemFlags.WriteOnly, Flow.Height * Flow.Width * sizeof(float), out error);
Kernel currentKernel = Cl.CreateKernel(program, "localGlobalFlow1", out error);
// Kernel arguiment declaration
error = Cl.SetKernelArg(currentKernel, 0, SimpleImage.intPtrSize, leftImageMemObject);
error |= Cl.SetKernelArg(currentKernel, 1, SimpleImage.intPtrSize, rightImageMemObject);
error |= Cl.SetKernelArg <float>(currentKernel, 2, uInputFlowMemObject);
error |= Cl.SetKernelArg <float>(currentKernel, 3, vInputFlowMemObject);
error |= Cl.SetKernelArg <float>(currentKernel, 4, OutFlow_U);
error |= Cl.SetKernelArg <float>(currentKernel, 5, OutFlow_V);
error |= Cl.SetKernelArg <float>(currentKernel, 6, alpha);
error |= Cl.SetKernelArg <float>(currentKernel, 7, threshold);
error |= Cl.SetKernelArg(currentKernel, 8, Flow.Width);
error |= Cl.SetKernelArg(currentKernel, 9, Flow.Height);
Event _event;
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)Image0.ImageWidth, (IntPtr)Image0.ImageHeight, (IntPtr)1 };
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)(Flow.Height * Flow.Width) };
error = Cl.EnqueueWriteImage(commandQueue, leftImageMemObject, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, Image0.ByteArray, 0, null, out _event);
error = Cl.EnqueueWriteImage(commandQueue, rightImageMemObject, Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, Image1.ByteArray, 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, uInputFlowMemObject, Bool.True, Flow.Array[1], 0, null, out _event);
error = Cl.EnqueueWriteBuffer <float>(commandQueue, vInputFlowMemObject, Bool.True, Flow.Array[0], 0, null, out _event);
error = Cl.EnqueueNDRangeKernel(commandQueue, currentKernel, 1, null, workGroupSizePtr, null, 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, OutFlow_U, Bool.True, 0, (resultFlowArray.Width * resultFlowArray.Height), resultFlowArray.Array[0], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.EnqueueReadBuffer <float>(commandQueue, OutFlow_V, Bool.True, 0, (resultFlowArray.Width * resultFlowArray.Height), resultFlowArray.Array[1], 0, null, out _event);
error = Cl.Finish(commandQueue);
Cl.ReleaseMemObject(leftImageMemObject);
Cl.ReleaseMemObject(rightImageMemObject);
Cl.ReleaseMemObject(uInputFlowMemObject);
Cl.ReleaseMemObject(vInputFlowMemObject);
Cl.ReleaseMemObject(OutFlow_U);
Cl.ReleaseMemObject(OutFlow_V);
Cl.ReleaseKernel(currentKernel);
return(resultFlowArray);
}
