void CameraFeed::getRGB(int x,int y,int &R, int &G, int &B) {
if (x>_width || y>_height) return;
DWORD Pix = getPos(x,y);
int Y,U,V;
getYUV(&data[Pix],Y,U,V);
getRGB(Y,U,V,R,G,B);
}
void CameraFeed::getRGB(BYTE *data,int &R,int &G,int &B) {
int Y,U,V;
getYUV(data,Y,U,V);
getRGB(Y,U,V,R,G,B);
}
void CameraFeed::setRGB(BYTE *Data,int R, int G, int B) {
int Y,U,V;
getYUV(R,G,B,Y,U,V);
setYUV(Data,Y,U,V);
}
void UnsharpMasking::applyPtmRGB(const PyramidCoeff& redCoeff, const PyramidCoeff& greenCoeff, const PyramidCoeff& blueCoeff, const QSize* mipMapSize, const PyramidNormals& normals, const RenderingInfo& info, unsigned char* buffer)
{
int offsetBuf = 0;
const PTMCoefficient* redPtr = redCoeff.getLevel(info.level);
const PTMCoefficient* greenPtr = greenCoeff.getLevel(info.level);
const PTMCoefficient* bluePtr = blueCoeff.getLevel(info.level);
const vcg::Point3f* normalsPtr = normals.getLevel(info.level);
float* lumMap = new float[info.width*info.height];
int width = mipMapSize[info.level].width();
if (type == 0) //classic unsharp masking
{
float* uvMap = new float[info.width*info.height*2];
LightMemoized lVec(info.light.X(), info.light.Y());
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y-info.offy)*info.width<<2;
int offset = y * width + info.offx;
int offset2 = (y - info.offy)*info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
float r = redPtr[offset].evalPoly(lVec) / 255.0;//evalPoly((int*)&(redPtr[offset][0]), info.light.X(), info.light.Y()) / 255.0;
float g = greenPtr[offset].evalPoly(lVec) / 255.0;//evalPoly((int*)&(greenPtr[offset][0]), info.light.X(), info.light.Y()) / 255.0;
float b = bluePtr[offset].evalPoly(lVec) / 255.0;//evalPoly((int*)&(bluePtr[offset][0]), info.light.X(), info.light.Y()) / 255.0;
getYUV(r, g, b, lumMap[offset2], uvMap[offset2*2], uvMap[offset2*2 + 1]);
offset++;
offset2++;
}
}
enhancedLuminance(lumMap, info.width, info.height, info.mode);
bool flag = (info.mode == LUM_UNSHARP_MODE || info.mode == SMOOTH_MODE || info.mode == CONTRAST_MODE || info.mode == ENHANCED_MODE);
if (flag)
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y-info.offy)*info.width<<2;
int offset2 =(y - info.offy)*info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
for (int i = 0; i < 3; i++)
buffer[offsetBuf + i] = tobyte(lumMap[offset2] * 255.0);
buffer[offsetBuf + 3] = 255;
offsetBuf += 4;
offset2++;
}
}
}
else
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y-info.offy)*info.width<<2;
int offset2 =(y - info.offy)*info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
float r, g, b;
getRGB(lumMap[offset2], uvMap[offset2*2], uvMap[offset2*2 +1], r, g, b);
buffer[offsetBuf] = tobyte(r*255);
buffer[offsetBuf + 1] = tobyte(g*255);
buffer[offsetBuf + 2] = tobyte(b*255);
buffer[offsetBuf + 3] = 255;
offsetBuf += 4;
offset2++;
}
}
}
delete[] uvMap;
}
else //luminance unsharp masking
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offset= y * width + info.offx;
int offset2 = (y - info.offy)*info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
lumMap[offset2] = getLum(normalsPtr[offset], info.light);
offset++;
offset2++;
}
}
enhancedLuminance(lumMap, info.width, info.height, info.mode);
bool flag = (info.mode == LUM_UNSHARP_MODE || info.mode == SMOOTH_MODE || info.mode == CONTRAST_MODE || info.mode == ENHANCED_MODE);
LightMemoized lVec(info.light.X(), info.light.Y());
if (flag)
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y-info.offy)*info.width<<2;
int offset = y * width + info.offx;
int offset2 = (y - info.offy)*info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
float lum = lumMap[offset2];
for (int i = 0; i < 3; i++)
buffer[offsetBuf + i] = tobyte(lum / 2.0 * 255.0);
buffer[offsetBuf + 3] = 255;
offsetBuf += 4;
offset++;
offset2++;
}
}
}
else
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y-info.offy)*info.width<<2;
int offset = y * width + info.offx;
int offset2 = (y - info.offy)*info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
float lum = lumMap[offset2];
buffer[offsetBuf] = tobyte(redPtr[offset].evalPoly(lVec)*lum);//evalPoly((int*)&(redPtr[offset][0]), info.light.X(), info.light.Y()) * lum);
buffer[offsetBuf + 1] = tobyte(greenPtr[offset].evalPoly(lVec)*lum);//evalPoly((int*)&(greenPtr[offset][0]), info.light.X(), info.light.Y()) * lum);
buffer[offsetBuf + 2] = tobyte(bluePtr[offset].evalPoly(lVec)*lum);//evalPoly((int*)&(bluePtr[offset][0]), info.light.X(), info.light.Y()) * lum);
buffer[offsetBuf + 3] = 255;
offsetBuf += 4;
offset++;
offset2++;
}
}
}
}
delete[] lumMap;
}
void UnsharpMasking::applyPtmLRGB(const PyramidCoeff& coeff, const PyramidRGB& rgb, const QSize* mipMapSize, const PyramidNormals& normals, const RenderingInfo& info, unsigned char* buffer)
{
int offsetBuf = 0;
const PTMCoefficient* coeffPtr = coeff.getLevel(info.level);
const unsigned char* rgbPtr = rgb.getLevel(info.level);
float* lumMap = new float[info.width*info.height];
int width = mipMapSize[info.level].width();
if (type == 0) //image unsharp masking
{
// Creates a map for Y component and a map for UV component.
float* uvMap = new float[info.width*info.height*2];
LightMemoized lVec(info.light.X(), info.light.Y());
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y-info.offy)*info.width<<2;
int offset = (y * width + info.offx)*3;
int offset2 = ((y - info.offy)*info.width)*2;
for (int x = info.offx; x < info.offx + info.width; x++)
{
float lum = coeffPtr[offset / 3].evalPoly(lVec) / 255.0;
float r = rgbPtr[offset]*lum / 255.0;
float g = rgbPtr[offset + 1]*lum / 255.0;
float b = rgbPtr[offset + 2]*lum / 255.0;
getYUV(r, g, b, lumMap[offset2 / 2], uvMap[offset2], uvMap[offset2 + 1]);
offset += 3;
offset2 += 2;
}
}
// Computes the enhanced luminance.
enhancedLuminance(lumMap, info.width, info.height, info.mode);
// Creates the output texture.
bool flag = (info.mode == LUM_UNSHARP_MODE || info.mode == SMOOTH_MODE || info.mode == CONTRAST_MODE ||info.mode == ENHANCED_MODE);
if (flag)
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y - info.offy) * info.width << 2;
int offset2 =(y - info.offy) * info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
for (int i = 0; i < 3; i++)
buffer[offsetBuf + i] = tobyte(lumMap[offset2] * 255.0);
buffer[offsetBuf + 3] = 255;
offsetBuf += 4;
offset2++;
}
}
}
else
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y - info.offy) * info.width << 2;
int offset2 =(y - info.offy)*info.width * 2;
for (int x = info.offx; x < info.offx + info.width; x++)
{
float r, g, b;
getRGB(lumMap[offset2 / 2], uvMap[offset2], uvMap[offset2 + 1], r, g, b);
buffer[offsetBuf ] = tobyte(r*255);
buffer[offsetBuf + 1] = tobyte(g*255);
buffer[offsetBuf + 2] = tobyte(b*255);
buffer[offsetBuf + 3] = 255;
offsetBuf += 4;
offset2 += 2;
}
}
}
delete[] uvMap;
}
else //unsharp masking luminance
{
// Creates a map for the polynomial luminance.
LightMemoized lVec(info.light.X(), info.light.Y());
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offset = y * width + info.offx;
int offset2 = (y - info.offy)*info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
lumMap[offset2] = coeffPtr[offset].evalPoly(lVec) / 255.0;
offset++;
offset2++;
}
}
// Computes the enhanced luminance
enhancedLuminance(lumMap, info.width, info.height, info.mode);
// Creates the output texture.
bool flag = (info.mode == LUM_UNSHARP_MODE || info.mode == SMOOTH_MODE || info.mode == CONTRAST_MODE || info.mode == ENHANCED_MODE);
if (flag)
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y - info.offy) * info.width <<2;
int offset2 = (y - info.offy) * info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
for (int i = 0; i < 3; i++)
buffer[offsetBuf + i] = tobyte(lumMap[offset2] / 2.0 * 255.0);
buffer[offsetBuf + 3] = 255;
offsetBuf += 4;
offset2++;
}
}
}
else
{
#pragma omp parallel for schedule(static,CHUNK)
for (int y = info.offy; y < info.offy + info.height; y++)
{
int offsetBuf = (y - info.offy) * info.width << 2;
int offset = (y * width + info.offx)*3;
int offset2 = (y - info.offy) * info.width;
for (int x = info.offx; x < info.offx + info.width; x++)
{
for (int i = 0; i < 3; i++)
buffer[offsetBuf + i] = tobyte(rgbPtr[offset + i] * lumMap[offset2]);
buffer[offsetBuf + 3] = 255;
offsetBuf += 4;
offset += 3;
offset2++;
}
}
}
}
delete[] lumMap;
}
v4r::meanVal BoundaryRelationsMeanColor::compute()
{
//@ep: TODO check preconditions -- not all of them are necessary
if(!have_cloud)
{
printf("[BoundaryRelationsMeanColor::compute] Error: No input cloud set.\n");
exit(0);
}
if(!have_boundary)
{
printf("[BoundaryRelationsMeanColor::compute] Error: No input border.\n");
exit(0);
}
v4r::meanVal meanColorDistance;
if(boundary.size() <= 0)
{
printf("[BoundaryRelationsMeanColor::compute] Warning: Boundary size is 0. This means that constants are different everywhere!\n");
meanColorDistance.mean = 0;
meanColorDistance.stddev = 0;
return meanColorDistance;
}
int boundaryLength = boundary.size();
// calculate mean depth
double totalColorDistance = 0.;
double totalColorDistanceStdDev = 0.;
std::vector<double> valuesColorDistance;
valuesColorDistance.reserve(boundaryLength);
for(unsigned int i=0; i<boundary.size(); i++)
{
double p0Y, p0U, p0V, p1Y, p1U, p1V;
getYUV(p0Y,p0U,p0V,cloud->points.at(boundary.at(i).idx1));
getYUV(p1Y,p1U,p1V,cloud->points.at(boundary.at(i).idx2));
double u1 = p0U/255 - p1U/255;
double u2 = u1 * u1;
double v1 = p0V/255 - p1V/255;
double v2 = v1 * v1;
double cDist = sqrt(u2 + v2);
totalColorDistance += cDist;
valuesColorDistance.push_back(totalColorDistance);
}
// normalize curvature sum and calculate curvature variance
//@ep: this shoule be separate function in the utils
if(boundaryLength > 0)
{
totalColorDistance /= boundaryLength;
for(unsigned i=0; i<valuesColorDistance.size(); i++)
{
//@ep: BUG why is it standart deviation???
totalColorDistanceStdDev += fabs(valuesColorDistance.at(i) - totalColorDistance);
}
totalColorDistanceStdDev /= boundaryLength;
}
else
{
std::printf("[BoundaryRelationsMeanCurvature::compute] Warning: Number of valid points is zero: totalColorDistance: %4.3f\n", totalColorDistance);
totalColorDistance = 0.;
totalColorDistanceStdDev = 0.;
}
meanColorDistance.mean = totalColorDistance;
meanColorDistance.stddev = totalColorDistanceStdDev;
return meanColorDistance;
}
