//Clean up before closing
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
isRunning = false;
isInit = false;
cuda_vbo_resource.Dispose();
texref.Dispose();
dvfield.Dispose();
vxfield.Dispose();
vyfield.Dispose();
planc2r.Dispose();
planr2c.Dispose();
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
GL.DeleteBuffers(1, ref vbo);
stopwatch.Dispose();
ctx.Dispose();
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
isRunning = false;
//Cleanup
if (graphicsres != null)
{
graphicsres.Dispose();
}
if (g_mparticles != null)
{
g_mparticles.Dispose();
}
if (stopwatch != null)
{
stopwatch.Dispose();
}
if (texref != null)
{
texref.Dispose();
}
if (g_dvfield != null)
{
g_dvfield.Dispose();
}
if (g_vxfield != null)
{
g_vxfield.Dispose();
}
if (g_vyfield != null)
{
g_vyfield.Dispose();
}
if (g_planc2r != null)
{
g_planc2r.Dispose();
}
if (g_planr2c != null)
{
g_planr2c.Dispose();
}
if (g_pVB != null)
{
g_pVB.Dispose();
}
if (g_pTexture != null)
{
g_pTexture.Dispose();
}
if (device != null)
{
device.Dispose();
}
if (d3d != null)
{
d3d.Dispose();
}
if (ctx != null)
{
ctx.Dispose();
}
}
private void myWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
//Stop render loop before closing
if (frameTimer != null)
{
frameTimer.Tick -= new EventHandler(frameTimer_Tick);
frameTimer.Stop();
}
//Cleanup
if (graphicsres != null)
{
graphicsres.Dispose();
}
if (g_mparticles != null)
{
g_mparticles.Dispose();
}
if (stopwatch != null)
{
stopwatch.Dispose();
}
if (texref != null)
{
texref.Dispose();
}
if (g_dvfield != null)
{
g_dvfield.Dispose();
}
if (g_vxfield != null)
{
g_vxfield.Dispose();
}
if (g_vyfield != null)
{
g_vyfield.Dispose();
}
if (g_planc2r != null)
{
g_planc2r.Dispose();
}
if (g_planr2c != null)
{
g_planr2c.Dispose();
}
if (g_pVB != null)
{
g_pVB.Dispose();
}
if (g_pTexture != null)
{
g_pTexture.Dispose();
}
if (device != null)
{
device.Dispose();
}
if (d3d != null)
{
d3d.Dispose();
}
if (ctx != null)
{
ctx.Dispose();
}
}
static void Main(string[] args)
{
const int nx = 2048;
const int ny = 2048;
// shifts applied to x and y data
const int x_shift = 5;
const int y_shift = 7;
ShrQATest.shrQAStart(args);
if ((nx % TILE_DIM != 0) || (ny % TILE_DIM != 0))
{
Console.Write("nx and ny must be multiples of TILE_DIM\n");
ShrQATest.shrQAFinishExit(args, ShrQATest.eQAstatus.QA_WAIVED);
}
// execution configuration parameters
dim3 grid = new dim3(nx / TILE_DIM, ny / TILE_DIM, 1);
dim3 threads = new dim3(TILE_DIM, TILE_DIM, 1);
// This will pick the best possible CUDA capable device
int devID = findCudaDevice(args);
//Load Kernel image from resources
string resName;
if (IntPtr.Size == 8)
{
resName = "simplePitchLinearTexture_x64.ptx";
}
else
{
resName = "simplePitchLinearTexture.ptx";
}
string resNamespace = "simplePitchLinearTexture";
string resource = resNamespace + "." + resName;
Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resource);
if (stream == null)
{
throw new ArgumentException("Kernel not found in resources.");
}
byte[] kernels = new byte[stream.Length];
int bytesToRead = (int)stream.Length;
while (bytesToRead > 0)
{
bytesToRead -= stream.Read(kernels, (int)stream.Position, bytesToRead);
}
CudaKernel PLKernel = ctx.LoadKernelPTX(kernels, "shiftPitchLinear");
CudaKernel ArrayKernel = ctx.LoadKernelPTX(kernels, "shiftArray");
CudaStopWatch stopwatch = new CudaStopWatch();
// ----------------------------------
// Host allocation and initialization
// ----------------------------------
float[] h_idata = new float[nx * ny];
float[] h_odata = new float[nx * ny];
float[] gold = new float[nx * ny];
for (int i = 0; i < nx * ny; ++i)
{
h_idata[i] = (float)i;
}
// ------------------------
// Device memory allocation
// ------------------------
// Pitch linear input data
CudaPitchedDeviceVariable <float> d_idataPL = new CudaPitchedDeviceVariable <float>(nx, ny);
// Array input data
CudaArray2D d_idataArray = new CudaArray2D(CUArrayFormat.Float, nx, ny, CudaArray2DNumChannels.One);
// Pitch linear output data
CudaPitchedDeviceVariable <float> d_odata = new CudaPitchedDeviceVariable <float>(nx, ny);
// ------------------------
// copy host data to device
// ------------------------
// Pitch linear
d_idataPL.CopyToDevice(h_idata);
// Array
d_idataArray.CopyFromHostToThis <float>(h_idata);
// ----------------------
// Bind texture to memory
// ----------------------
// Pitch linear
CudaTextureLinearPitched2D <float> texRefPL = new CudaTextureLinearPitched2D <float>(PLKernel, "texRefPL", CUAddressMode.Wrap, CUFilterMode.Point, CUTexRefSetFlags.NormalizedCoordinates, CUArrayFormat.Float, d_idataPL);
CudaTextureArray2D texRefArray = new CudaTextureArray2D(ArrayKernel, "texRefArray", CUAddressMode.Wrap, CUFilterMode.Point, CUTexRefSetFlags.NormalizedCoordinates, d_idataArray);
// ---------------------
// reference calculation
// ---------------------
for (int j = 0; j < ny; j++)
{
int jshift = (j + y_shift) % ny;
for (int i = 0; i < nx; i++)
{
int ishift = (i + x_shift) % nx;
gold[j * nx + i] = h_idata[jshift * nx + ishift];
}
}
// ----------------
// shiftPitchLinear
// ----------------
ctx.ClearMemory(d_odata.DevicePointer, 0, d_odata.TotalSizeInBytes);
PLKernel.BlockDimensions = threads;
PLKernel.GridDimensions = grid;
stopwatch.Start();
for (int i = 0; i < NUM_REPS; i++)
{
PLKernel.Run(d_odata.DevicePointer, (int)(d_odata.Pitch / sizeof(float)), nx, ny, x_shift, y_shift);
}
stopwatch.Stop();
stopwatch.StopEvent.Synchronize();
float timePL = stopwatch.GetElapsedTime();
// check results
d_odata.CopyToHost(h_odata);
bool res = cutComparef(gold, h_odata);
bool success = true;
if (res == false)
{
Console.Write("*** shiftPitchLinear failed ***\n");
success = false;
}
// ----------
// shiftArray
// ----------
ctx.ClearMemory(d_odata.DevicePointer, 0, d_odata.TotalSizeInBytes);
ArrayKernel.BlockDimensions = threads;
ArrayKernel.GridDimensions = grid;
stopwatch.Start();
for (int i = 0; i < NUM_REPS; i++)
{
ArrayKernel.Run(d_odata.DevicePointer, (int)(d_odata.Pitch / sizeof(float)), nx, ny, x_shift, y_shift);
}
stopwatch.Stop();
stopwatch.StopEvent.Synchronize();
float timeArray = stopwatch.GetElapsedTime();
// check results
d_odata.CopyToHost(h_odata);
res = cutComparef(gold, h_odata);
if (res == false)
{
Console.Write("*** shiftArray failed ***\n");
success = false;
}
float bandwidthPL = 2.0f * 1000.0f * nx * ny * sizeof(float) / (1e+9f) / (timePL / NUM_REPS);
float bandwidthArray = 2.0f * 1000.0f * nx * ny * sizeof(float) / (1e+9f) / (timeArray / NUM_REPS);
Console.Write("\nBandwidth (GB/s) for pitch linear: {0}; for array: {1}\n",
bandwidthPL, bandwidthArray);
float fetchRatePL = nx * ny / 1e+6f / (timePL / (1000.0f * NUM_REPS));
float fetchRateArray = nx * ny / 1e+6f / (timeArray / (1000.0f * NUM_REPS));
Console.Write("\nTexture fetch rate (Mpix/s) for pitch linear: {0}; for array: {1}\n\n",
fetchRatePL, fetchRateArray);
// cleanup
texRefPL.Dispose();
texRefArray.Dispose();
d_idataPL.Dispose();
d_idataArray.Dispose();
d_odata.Dispose();
stopwatch.Dispose();
ctx.Dispose();
ShrQATest.shrQAFinishExit(args, (success == true) ? ShrQATest.eQAstatus.QA_PASSED : ShrQATest.eQAstatus.QA_FAILED);
}
private void Btn_ProcessPEF_Click(object sender, EventArgs e)
{
if (pef == null)
{
return;
}
denoiseAndDemoisaic.LoadNetwork("epoch_" + learningRate.ToString(CultureInfo.InvariantCulture) + "_" + noiseLevelsFolders[cmb_IsoValue.SelectedIndex] + "_1999.cnn");
NPPImage_16uC1 rawTemp = new NPPImage_16uC1(pef.RawWidth, pef.RawHeight);
rawTemp.CopyToDevice(pef.RawImage);
rawTemp.Convert(imageBayer);
float whiteLevelAll = pef.WhiteLevel.Value;
float3 whitePoint = new float3(whiteLevelAll, whiteLevelAll, whiteLevelAll);
float3 blackPoint = new float3(pef.BlackPoint.Value[0], pef.BlackPoint.Value[1], pef.BlackPoint.Value[3]);
whitePoint -= blackPoint;
float scale = pef.Scaling.Value;
float3 scaling = new float3(pef.WhitePoint.Value[0] / scale, pef.WhitePoint.Value[1] / scale, pef.WhitePoint.Value[3] / scale);
inputImage32f.Set(new float[] { 0, 0, 0 });
deBayerGreenKernel.RunSafe(imageBayer, inputImage32f, blackPoint, scaling);
deBayerRedBlueKernel.RunSafe(imageBayer, inputImage32f, blackPoint, scaling);
inputImage32f.Div(new float[] { whitePoint.x *scaling.x, whitePoint.y *scaling.y, whitePoint.z *scaling.z });
highlightRecoveryKernel.RunSafe(inputImage32f, new float3(scaling.x, scaling.y, scaling.z), 1);
inputImage32f.Sub(new float[] { 0.5f, 0.5f, 0.5f }, noiseImage32f);
Console.WriteLine("Start denoising...");
CudaStopWatch csw = new CudaStopWatch();
csw.Start();
denoiseAndDemoisaic.RunImage(noiseImage32f, resultImage32f);
csw.Stop();
Console.WriteLine("Needed time: " + csw.GetElapsedTime() + " [msec]");
csw.Dispose();
resultImage32f.Add(new float[] { 0.5f, 0.5f, 0.5f });
ColorManagment cm = new ColorManagment();
float3 wp = 1.0f / scaling;
double3 wb = new double3(wp.x, wp.y, wp.z);
double2 neutralXY = cm.NeutralToXY(wb);
cm.SetWhiteXY(neutralXY);
ColorMatrix camToXYZ2 = cm.CameraToPCS;
ColorMatrix d50Tod65 = new ColorMatrix(new double[] { 0.9555766, -0.0230393, 0.0631636, -0.0282895, 1.0099416, 0.0210077, 0.0122982, -0.0204830, 1.3299098 });
ColorMatrix d65TosRGB = new ColorMatrix(new double[] { 3.2406, -1.5372, -0.4986, -0.9689, 1.8758, 0.0415, 0.0557, -0.2040, 1.0570 });
ColorMatrix final = d65TosRGB * d50Tod65 * camToXYZ2;
float[] matData = new float[9];
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
matData[j + i * 3] = (float)final[i, j];
}
}
camToXYZKernel.RunSafe(inputImage32f, matData);
camToXYZKernel.RunSafe(resultImage32f, matData);
//This is a LUT that maps well to most of the JPEGs out of camera, but not always... found somewhere on internet, if I remember well from darktable?
float[] x = new float[] { 0,
0.004754f,
0.009529f,
0.023713f,
0.031866f,
0.046734f,
0.059989f,
0.088415f,
0.13661f,
0.17448f,
0.205192f,
0.228896f,
0.286411f,
0.355314f,
0.440014f,
0.567096f,
0.620597f,
0.760355f,
0.875139f,
1 };
float[] y = new float[] { 0,
0.002208f,
0.004214f,
0.013508f,
0.020352f,
0.034063f,
0.052413f,
0.09603f,
0.190629f,
0.256484f,
0.30743f,
0.348447f,
0.42868f,
0.513527f,
0.607651f,
0.732791f,
0.775968f,
0.881828f,
0.960682f,
1 };
CudaDeviceVariable <float> d_x = x;
CudaDeviceVariable <float> d_y = y;
inputImage32f.LUTCubic(new CudaDeviceVariable <float>[] { d_y, d_y, d_y }, new CudaDeviceVariable <float>[] { d_x, d_x, d_x });
resultImage32f.LUTCubic(new CudaDeviceVariable <float>[] { d_y, d_y, d_y }, new CudaDeviceVariable <float>[] { d_x, d_x, d_x });
convertRGBTosRGBKernel.RunSafe(inputImage32f);
convertRGBTosRGBKernel.RunSafe(resultImage32f);
inputImage32f.Convert(noisyImage8u, NppRoundMode.Near);
resultImage32f.Convert(resultImage8u, NppRoundMode.Near);
noisyImage8u.SetRoi(0, 0, bmpNoisy.Width - 4, bmpNoisy.Height - 4);
noisyImage8u.CopyToHostRoi(bmpNoisy, new NppiRect(2, 2, bmpNoisy.Width - 4, bmpNoisy.Height - 4));
resultImage8u.SetRoi(0, 0, bmpResult.Width - 16, bmpResult.Height - 16);
resultImage8u.CopyToHostRoi(bmpResult, new NppiRect(8, 8, bmpResult.Width - 16, bmpResult.Height - 16));
pictureBox2.Image = bmpNoisy;
pictureBox3.Image = bmpResult;
rawTemp.Dispose();
d_y.Dispose();
d_x.Dispose();
}
private void btn_Process_Click(object sender, EventArgs e)
{
if (bmpInput == null)
{
return;
}
denoiseAndDemoisaic.LoadNetwork("epoch_" + learningRate.ToString(CultureInfo.InvariantCulture) + "_" + noiseLevelsFolders[cmb_IsoValue.SelectedIndex] + "_1999.cnn");
if (bmpInput.PixelFormat == PixelFormat.Format32bppArgb)
{
inputImage8uC4.CopyToDeviceRoi(bmpInput, new NppiRect(0, 0, bmpInput.Width, bmpInput.Height));
//Convert C4 to C3 and BGR to RGB
inputImage8uC4.Copy(inputImage8uC1, 0);
inputImage8uC1.Copy(inputImage8uC3, 2);
inputImage8uC4.Copy(inputImage8uC1, 1);
inputImage8uC1.Copy(inputImage8uC3, 1);
inputImage8uC4.Copy(inputImage8uC1, 2);
inputImage8uC1.Copy(inputImage8uC3, 0);
}
else
{
inputImage8uC3.CopyToDeviceRoi(bmpInput, new NppiRect(0, 0, bmpInput.Width, bmpInput.Height));
inputImage8uC3.ColorTwist(twist);
}
inputImage8uC3.Convert(inputImage32f);
inputImage32f.Div(new float[] { 255, 255, 255 });
NppiRect oldRoi = new NppiRect(0, 0, inputImage32f.WidthRoi, inputImage32f.HeightRoi);
IEnumerable <Tiler.RoiInputOutput> rois = Tiler.GetROIs(oldRoi, TileSize, 0);
foreach (var roi in rois)
{
inputImage32f.SetRoi(roi.inputROI);
tile.ResetRoi();
inputImage32f.Copy(tile);
tile.SetRoi(roi.outputROI);
imageBayer.SetRoi(roi.positionInFinalImage);
createBayerKernel.RunSafe(CuRandStates, tile, imageBayer, noiseLevels[cmb_IsoValue.SelectedIndex], 0);
}
imageBayer.SetRoi(oldRoi);
inputImage32f.SetRoi(oldRoi);
deBayerGreenKernel.RunSafe(imageBayer, inputImage32f, new float3(), new float3(1, 1, 1));
deBayerRedBlueKernel.RunSafe(imageBayer, inputImage32f, new float3(), new float3(1, 1, 1));
inputImage32f.Mul(new float[] { 255, 255, 255 }, noiseImage32f);
noiseImage32f.Convert(noisyImage8u, NppRoundMode.Near);
noisyImage8u.ColorTwist(twist);
noisyImage8u.CopyToHostRoi(bmpNoisy, new NppiRect(0, 0, bmpNoisy.Width, bmpNoisy.Height));
inputImage32f.Sub(new float[] { 0.5f, 0.5f, 0.5f });
CudaStopWatch csw = new CudaStopWatch();
csw.Start();
denoiseAndDemoisaic.RunImage(inputImage32f, resultImage32f);
csw.Stop();
Console.WriteLine("Needed time: " + csw.GetElapsedTime() + " [msec]");
csw.Dispose();
resultImage32f.Add(new float[] { 0.5f, 0.5f, 0.5f });
resultImage32f.Mul(new float[] { 255, 255, 255 });
resultImage32f.Convert(resultImage8u, NppRoundMode.Near);
resultImage8u.ColorTwist(twist);
resultImage8u.SetRoi(0, 0, bmpResult.Width - 16, bmpResult.Height - 16);
resultImage8u.CopyToHostRoi(bmpResult, new NppiRect(8, 8, bmpResult.Width - 16, bmpResult.Height - 16));
pictureBox2.Image = bmpNoisy;
pictureBox3.Image = bmpResult;
}
