mmtalaie
/
kernel-tester
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

write scanConversion Convex but not done

scan-conversion-convex
MMT 5 years ago
parent
2d5baef77d
commit
65636e447f
2 changed files with 271 additions and 3 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      header/ScenarioParams.h
  2. 271
      source/model/processor/strategies/ScanConversion.cpp

3
header/ScenarioParams.h
View File

@ -16,7 +16,8 @@ typedef struct ScenGenOutput_t
field_t<bool> virtualConvex;
field_t<float> depth;
field_t<float> probeRadius;
field_t<float> fieldOfView;
field_t<float> fieldOfView;
field_t<float> probeGeometry;
field_t<float> probeFieldOfView;
field_t<float> startDepth;
field_t<int> rxLineNo;

271
source/model/processor/strategies/ScanConversion.cpp
View File

@ -28,8 +28,275 @@ void ScanConversion::cpuProcess(ScenGenOutput_t params)
{
auto context = _openCLHelper.getContext();
auto queue = BIP::getInstance()->CLQueue;
//convex
if (params.probeGeometry.value)
{
if(params.outputWidth.isUpdated || params.outputHeight.isUpdated)
{
if(_gridPixelXPos)
delete[] _gridPixelXPos;
if(_gridPixelXPos)
delete[] _gridPixelXPos;
_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.probeRadius.isUpdated ||
params.fieldOfView.isUpdated || params.angle.isUpdated ||
params.startDepth.isUpdated || params.startDepth.isUpdated ||
params.outputWidth.isUpdated || params.outputHeight.isUpdated||
params.steering.isUpdated)
{
auto maxX = params.probeRadius.value*sinf(params.fieldOfView.value/2)+params.depth.value*sinf(params.angle.value/2);
auto minX = -1 * maxX;
auto maxZ = params.depth.value + params.probeRadius.value;
auto minZ = params.probeRadius.value*cosf(params.fieldOfView.value/2)+params.startDepth.value*cosf(params.angle.value/2);
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 baseIndex = i * params.outputHeight.value;
for (auto j = 0; j < params.outputWidth.value; ++j)
{
_gridPixelXPos[baseIndex+j] = minX + baseX * j;
_gridPixelZPos[baseIndex+j] = minZ + temp;
}
}
if(_gridPixelR)
delete[] _gridPixelR;
if(_gridPixelTheta)
delete[] _gridPixelTheta;
auto virtualOriginalZ = params.probeRadius.value * (cosf(params.fieldOfView.value/2) -
sinf(params.fieldOfView.value/2) /
tanf(params.angle.value/2));
auto virtualOriginalZ2 = powf(virtualOriginalZ, 2);
auto minR = params.probeRadius.value - virtualOriginalZ + params.startDepth.value;
auto maxR = params.probeRadius.value + params.depth.value;
auto minTheta = (-1 * params.angle.value) / 2 - abs(params.steering.value);
auto maxTheta = params.angle.value / 2 + abs(params.steering.value);
auto strSin = 2 * sinf(params.steering.value);
auto maxInterceptTheta = params.fieldOfView.value / 2;
auto radius2 = powf(params.probeRadius.value, 2.0);
if(params.steering.value == 0.0f)
{
for (auto i = 0; i < params.outputWidth.value * params.outputHeight.value; ++i)
{
auto x = _gridPixelXPos[i];
auto z = _gridPixelZPos[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 = virtualOriginalZ;
auto beta = (virtualOriginalZ - z) / x;
if (x == 0.0f)
interceptTheta = 0;
else
{
interceptX = (alpha * beta + sqrtf(-1 * powf(alpha, 2) + (powf(beta, 2) + 1)* radius2)) / (powf(beta, 2) + 1);
interceptZ = alpha - beta * interceptX;
interceptTheta = atan2f(interceptX, interceptTheta);
}
if(interceptTheta > maxInterceptTheta || interceptTheta < (-1 * 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, interceptTheta);
if(interceptTheta > maxInterceptTheta || interceptTheta < (-1 * maxInterceptTheta))
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
else
{
auto gridPixelAx = sqrtf(powf((x - params.probeRadius.value * sinf(interceptTheta)), 2) +
powf((z - params.probeRadius.value * cosf(interceptTheta)), 2));
if(gridPixelAx >= params.startDepth.value && gridPixelAx <= params.depth.value)
{
_gridPixelR[i] = params.probeRadius.value + gridPixelAx;
_gridPixelTheta[i] = interceptZ;
}
else
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
}
}
else
{
auto gridPixelAx = sqrtf(powf((x - params.probeRadius.value * sinf(interceptTheta)), 2) +
powf((z - params.probeRadius.value * cosf(interceptTheta)), 2));
if(gridPixelAx >= params.startDepth.value && gridPixelAx <= params.depth.value)
{
_gridPixelR[i] = params.probeRadius.value + gridPixelAx;
_gridPixelTheta[i] = interceptZ;
}
else
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
}
}
else
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
}
}
else
{
for (auto i = 0; i < params.outputWidth.value * params.outputHeight.value; ++i)
{
auto x = _gridPixelXPos[i];
auto z = _gridPixelZPos[i];
auto pixelTheta = atan2f(x, z - virtualOriginalZ);
auto pixelR = sqrtf(powf(x, 2) + powf((z - virtualOriginalZ), 2));
if(pixelR >= minR && pixelR <= maxR && pixelTheta >= maxTheta)
{
auto ro = pixelR / strSin;
auto xo = ro * cosf(params.steering.value - pixelTheta);
auto zo = ro * sinf(params.steering.value - 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 < (-1 * maxInterceptTheta))
{
interceptZ = -1 * sqrtf(radius2 - powf(interceptX , 2));
interceptTheta = atan2(interceptX, interceptZ);
if(interceptTheta > maxInterceptTheta || interceptTheta < (-1 * maxInterceptTheta))
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
else
{
auto gridPixelAx = sqrtf(powf((x - params.probeRadius.value) * sinf(interceptTheta), 2) +
powf((z - params.probeRadius.value) * cosf(interceptTheta), 2));
if(gridPixelAx >= params.startDepth.value && gridPixelAx <= params.depth.value)
{
_gridPixelR[i] = params.probeRadius.value + gridPixelAx;
_gridPixelTheta[i] = interceptTheta;
}
else
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
}
}
else
{
auto gridPixelAx = sqrtf(powf((x - params.probeRadius.value) * sinf(interceptTheta), 2) +
powf((z - params.probeRadius.value) * cosf(interceptTheta), 2));
if(gridPixelAx >= params.startDepth.value && gridPixelAx <= params.depth.value)
{
_gridPixelR[i] = params.probeRadius.value + gridPixelAx;
_gridPixelTheta[i] = interceptTheta;
}
else
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 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 < (-1 * maxInterceptTheta))
{
interceptX = (alpha * beta - sqrtf(-1 * powf(alpha, 2) + (powf(beta,2) + 1) * radius2)) / (powf(beta, 2) + 1);
interceptZ = alpha - beta * interceptX; // TODO:: can delete this line
interceptTheta = atan2f(interceptX, interceptZ);
if(interceptTheta > maxInterceptTheta || interceptTheta < (-1 * maxInterceptTheta))
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
else
{
auto gridPixelAx = sqrtf(powf((x - params.probeRadius.value) * sinf(interceptTheta), 2) +
powf((z - params.probeRadius.value) * cosf(interceptTheta), 2));
if(gridPixelAx >= params.startDepth.value && gridPixelAx <= params.depth.value)
{
_gridPixelR[i] = params.probeRadius.value + gridPixelAx;
_gridPixelTheta[i] = interceptTheta;
}
else
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
}
}
else
{
auto gridPixelAx = sqrtf(powf((x - params.probeRadius.value) * sinf(interceptTheta), 2) +
powf((z - params.probeRadius.value) * cosf(interceptTheta), 2));
if(gridPixelAx >= params.startDepth.value && gridPixelAx <= params.depth.value)
{
_gridPixelR[i] = params.probeRadius.value + gridPixelAx;
_gridPixelTheta[i] = interceptTheta;
}
else
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
}
}
}
else
{
_gridPixelR[i] = 0;
_gridPixelTheta[i] = 0;
}
}
}
}
//TODO:: write after convex
// if(params.rxLineNo.isUpdated || params.rxFocusPointNo.isUpdated ||
// params.minScanAx.isUpdated || params.rxPointDax)
}
//virtual convex
if(params.virtualConvex.value)
else if(params.virtualConvex.value)
{
if(params.outputWidth.isUpdated|| params.outputHeight.isUpdated)
{
@ -188,7 +455,7 @@ void ScanConversion::cpuProcess(ScenGenOutput_t params)
params.outputHeight.value *
sizeof (myflt),
_gridPixelR);
queue.enqueueWriteBuffer(*_queryX, CL_TRUE, 0,
queue.enqueueWriteBuffer(*_queryX, CL_TRUE, 0,
params.outputWidth.value *
params.outputHeight.value *
sizeof (myflt),

Write Preview
Loading…
Cancel
Save