void ProcessImage::ProcessSaveRes(Image &image, vector<REAL>&r,
vector<REAL>& g, vector<REAL>& b, const string&ofile) {// Work on each color channel RGB
if (gamma == 1 && !dog)
ReadImage(image, r, g, b);
if (gamma != 1)// Perform the gamma normalization of the image...
// image magick gamma is x=y^(1/gamma); so sending
// 1/gamma leads to x=y^gamma;
// to have tip style normalization...
{
image.gamma(1 / gamma);
if (!dog)
ReadImage(image, r, g, b);
}
if (dog) {
// Now using ImageMagick Implementation for padding
UINT k2size = ceil(k2 * 3);
Image image2 = image;
// 3 to include 3 sigma bell
image.blur(ceil(k1 * 3), k1);// applies separable filters...
image2.blur(k2size, k2);
SubtractImage(image, image2, r, g, b);
}
WriteImageFile(ofile + "_dog", r, g, b, image.rows(), image.columns());
if (constr || coneq) {
REAL imgstat[6];
ExtractChannelStats(r, g, b, imgstat);
if (constr)
DoContrastStretching(r, g, b, imgstat);
if (coneq)
DoContrastEqualization(r, g, b, imgstat);
}
}
bool ImageSaveManager::Save2DImage(GLuint glType, const string &fileName, const ImageData *imageData,ImageSaveFiles &retFileNames) const
{
if(glType != GL_TEXTURE_2D &&
glType != GL_TEXTURE_RECTANGLE &&
glType != GL_TEXTURE_1D_ARRAY)
{
LOGERR(("ImageSaveManager::Save2DImage - unsupported image type"));
return false;
}
GLint width,height;
GLV.glGetTexLevelParameteriv(glType,0,GL_TEXTURE_WIDTH,&width);
GLV.glGetTexLevelParameteriv(glType,0,GL_TEXTURE_HEIGHT,&height);
//Catch bad values
if(width == 0 || height == 0)
{
LOGERR(("ImageSaveManager::Save2DImage - invalid width/height on image"));
return false;
}
//Get the basic type of this texture (RGB,depth etc)
GLenum baseTextureFormat;
if(!GetBaseTextureFormat(glType,baseTextureFormat))
{
return false;
}
//Create a new image to write to
corona::Image * newImage = corona::CreateImage(width,height,corona::PF_R8G8B8A8);
if(!newImage)
{
return false;
}
//Fill the image buffer
RetrieveImageData(glType, baseTextureFormat, newImage);
//Write the image out
if(!WriteImageFile(fileName,newImage,retFileNames))
{
delete newImage;
return false;
}
//Write an icon version (can fail if icon writing is not enabled)
WriteImageIconFile(fileName,newImage,retFileNames);
//Clean up
delete newImage;
return true;
}
bool ImageSaveManager::SaveDummyImage(const string &fileName, const ImageData *imageData,ImageSaveFiles &retFileNames) const
{
const uint DUMMY_IMG_SIZE = 14;
//Create a new image to write to
corona::Image * newImage = corona::CreateImage(DUMMY_IMG_SIZE,DUMMY_IMG_SIZE,corona::PF_R8G8B8A8);
if(!newImage)
{
return false;
}
// Load in a question mark as the dummy image
static GLubyte questionMarkImg[DUMMY_IMG_SIZE*DUMMY_IMG_SIZE] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,53,58,23,0,0,0,0,0,0,0,0,10,165,
252,255,255,254,177,18,0,0,0,0,0,0,152,255,255,255,255,255,255,174,0,0,
0,0,0,0,191,226,246,66,36,255,255,246,0,0,0,0,0,0,0,0,0,1,127,255,255,200,
0,0,0,0,0,0,0,0,14,180,255,255,218,35,0,0,0,0,0,0,0,0,162,255,255,174,13,
0,0,0,0,0,0,0,0,0,226,255,244,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,255,255,255,0,0,0,0,0,0,0,0,0,0,0,255,255,255,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
GLubyte * dstPixels = (GLubyte *)newImage->getPixels();
for(uint i = 0; i < (DUMMY_IMG_SIZE * DUMMY_IMG_SIZE); i++)
{
dstPixels[0] = questionMarkImg[i];
dstPixels[1] = questionMarkImg[i];
dstPixels[2] = questionMarkImg[i];
dstPixels[3] = 255;
dstPixels += 4;
}
//Write the image out
if(!WriteImageFile(fileName,newImage,retFileNames))
{
delete newImage;
return false;
}
//Write an icon version (can fail if icon writing is not enabled)
WriteImageIconFile(fileName,newImage,retFileNames);
//Clean up
delete newImage;
return true;
}
bool ImageSaveManager::Save1DImage(const string &fileName, const ImageData *imageData,ImageSaveFiles &retFileNames) const
{
GLint width;
GLV.glGetTexLevelParameteriv(GL_TEXTURE_1D,0,GL_TEXTURE_WIDTH,&width);
//Catch bad values
if(width == 0)
{
LOGERR(("ImageSaveManager::Save1DImage - invalid width on image"));
return false;
}
//Get the basic type of this texture (RGB,depth etc)
GLenum baseTextureFormat;
if(!GetBaseTextureFormat(GL_TEXTURE_1D,baseTextureFormat))
{
return false;
}
//Create a new image to write to
corona::Image * newImage = corona::CreateImage(width,1,corona::PF_R8G8B8A8);
if(!newImage)
{
return false;
}
//Fill the image buffer
RetrieveImageData(GL_TEXTURE_1D, baseTextureFormat, newImage);
//Write the image out
if(!WriteImageFile(fileName,newImage,retFileNames))
{
delete newImage;
return false;
}
//Write an icon version (can fail if icon writing is not enabled)
WriteImageIconFile(fileName,newImage,retFileNames);
//Clean up
delete newImage;
return true;
}
int ImageOperationECB(int argc, char** argv, bool bEncrypt = true)
{
// Parse arguments
// OpenCL arguments: platform and device
cl_int err;
int iPlatform = GetArgInt (argc, argv, "p");
int iDevice = GetArgInt (argc, argv, "d");
char* sInFile = GetArgString(argc, argv, "in");
char* sOutFile = GetArgString(argc, argv, "out");
if (sInFile == NULL || sOutFile == NULL || !FileExists(sInFile))
{
PrintUsage();
return -1;
}
// Initialize ImageMagick
Magick::InitializeMagick(*argv);
ImageData img = ReadImageFile(sInFile);
// Allocate Host Memory
unsigned char key[16] = {
0x2B, 0x7E, 0x15, 0x16,
0x28, 0xAE, 0xD2, 0xA6,
0xAB, 0xF7, 0x15, 0x88,
0x09, 0xCF, 0x4F, 0x3C};
unsigned char* roundKeys = NULL;
int rounds = 0;
ComputeRoundKeys(&roundKeys, &rounds, 16, key);
// Set-up OpenCL Platform
OCL_Device* pOCL_Device = new OCL_Device(iPlatform, iDevice);
pOCL_Device->SetBuildOptions("");
pOCL_Device->PrintInfo();
// Set up OpenCL
cl_kernel Kernel = pOCL_Device->GetKernel("aes-kernel.cl",
bEncrypt ? "AES_ECB_Encrypt" : "AES_ECB_Decrypt");
// Allocate Device Memory
cl_mem d_A = pOCL_Device->DeviceMalloc(0, img.padded_bytes);
cl_mem d_B = pOCL_Device->DeviceMalloc(1, img.padded_bytes);
cl_mem d_C = pOCL_Device->DeviceMalloc(2, rounds * 16);
// Copy Image to Device
pOCL_Device->CopyBufferToDevice(img.data, 0, img.padded_bytes);
// Keys
pOCL_Device->CopyBufferToDevice(roundKeys, 2, rounds * 16);
// Set Kernel Arguments
cl_int _num = img.padded_bytes / 16;
err = clSetKernelArg(Kernel, 0, sizeof(cl_mem), &d_A);
CHECK_OPENCL_ERROR(err);
err = clSetKernelArg(Kernel, 1, sizeof(cl_mem), &d_B);
CHECK_OPENCL_ERROR(err);
err = clSetKernelArg(Kernel, 2, sizeof(cl_mem), &d_C);
CHECK_OPENCL_ERROR(err);
err = clSetKernelArg(Kernel, 3, sizeof(cl_int), &rounds);
CHECK_OPENCL_ERROR(err);
err = clSetKernelArg(Kernel, 4, sizeof(cl_int), &_num);
CHECK_OPENCL_ERROR(err);
// Wait for previous action to finish
err = clFinish(pOCL_Device->GetQueue());
CHECK_OPENCL_ERROR(err);
size_t off = 0;
size_t num = img.padded_bytes / 16;
size_t threads = 256;
// Run the kernel
err = clEnqueueNDRangeKernel(pOCL_Device->GetQueue(),
Kernel, 1, NULL, &num, &threads, 0, NULL, NULL);
CHECK_OPENCL_ERROR(err);
// Wait for kernel to finish
err = clFinish(pOCL_Device->GetQueue());
CHECK_OPENCL_ERROR(err);
// Copy Data From Device
pOCL_Device->CopyBufferToHost (img.data, 1, img.padded_bytes);
// Free resources
delete pOCL_Device;
delete[] roundKeys;
// Write Output data
WriteImageFile(sOutFile, img);
free(img.data);
return 0;
}
bool ImageSaveManager::SaveCubeImage(const string &fileName, const ImageData *imageData,ImageSaveFiles &retFileNames) const
{
uint i;
GLint width[6],height[6];
GLenum baseTextureFormat[6];
//DT_TODO: Need to handle cube maps where not all faces are filled out.
//Get the width/height of all faces
for(i=0;i<6;i++)
{
GLV.glGetTexLevelParameteriv(cubeMapTypes[i],0,GL_TEXTURE_WIDTH,&width[i]);
GLV.glGetTexLevelParameteriv(cubeMapTypes[i],0,GL_TEXTURE_HEIGHT,&height[i]);
//If the widths are valid
if(width[i] > 0 && height[i] > 0)
{
//Get the basic type of this texture (RGB,depth etc)
if(!GetBaseTextureFormat(cubeMapTypes[i],baseTextureFormat[i]))
{
return false;
}
}
else
{
//Init to zero
baseTextureFormat[i] = 0;
}
}
//Get the max width and height
GLint maxWidth = width[0];
GLint maxHeight = height[0];
for(i=1;i<6;i++)
{
//Get the maximum
if(width[i] > maxWidth)
{
maxWidth = width[i];
}
if(height[i] > maxHeight)
{
maxHeight = height[i];
}
}
//Catch bad values
if(maxWidth == 0 || maxHeight == 0)
{
LOGERR(("ImageSaveManager::SaveCubeImage - invalid width/height on image"));
return false;
}
//Create all the images
corona::Image *newImages[6];
for(i=0;i<6;i++)
{
//Loop and get all the images
if(width[i] > 0 && height[i] > 0)
{
newImages[i] = corona::CreateImage(width[i],height[i],corona::PF_R8G8B8A8);
//Only get for a valid texture
if(newImages[i])
{
//Fill the image buffer
RetrieveImageData(cubeMapTypes[i], baseTextureFormat[i],newImages[i]);
}
}
else
{
newImages[i] = NULL;
}
}
bool retValue = false;
//If we are not tiling the images, write each individually
if(!cubeMapTile)
{
//The index of the image to be used as an icon
int iconIndex = -1;
//Write all the images out
for(i=0;i<6;i++)
{
//If the image exists, write it
if(newImages[i])
{
//Assign a unique name to the face
string faceName = fileName + cubeMapFaceNames[i];
//Flag this image to be the icon version
iconIndex=i;
//Cache return result
if(WriteImageFile(faceName,newImages[i],retFileNames))
{
retValue = true;
}
}
}
//If there is a valid image to be used as an icon, write it out
if(iconIndex != -1)
{
//Write an icon version (can fail if icon writing is not enabled)
WriteImageIconFile(fileName,newImages[iconIndex],retFileNames);
}
}
else
{
//Tile the cube maps together into one image
corona::Image * tileImage = CreateTileCubeMapImage(maxWidth,maxHeight,newImages);
if(tileImage)
{
//Cache return result
retValue = WriteImageFile(fileName,tileImage,retFileNames);
//Write a icon version
WriteImageIconFile(fileName,tileImage,retFileNames);
//Delete the tile image
delete tileImage;
}
else
{
LOGERR(("ImageSaveManager::SaveCubeImage - Unable to tile cube map images"));
}
}
//Clean up
for(i=0;i<6;i++)
{
//If the image exists, delete it
if(newImages[i])
{
delete newImages[i];
}
}
return retValue;
}
bool ImageSaveManager::Save3DImage(GLuint glType, const string &fileName, const ImageData *imageData,ImageSaveFiles &retFileNames) const
{
if(glType != GL_TEXTURE_3D &&
glType != GL_TEXTURE_2D_ARRAY)
{
LOGERR(("ImageSaveManager::Save3DImage - unsupported image type"));
return false;
}
GLint width,height,depth;
GLV.glGetTexLevelParameteriv(glType,0,GL_TEXTURE_WIDTH,&width);
GLV.glGetTexLevelParameteriv(glType,0,GL_TEXTURE_HEIGHT,&height);
GLV.glGetTexLevelParameteriv(glType,0,GL_TEXTURE_DEPTH,&depth);
//Catch bad values
if(width == 0 || height == 0 || depth == 0)
{
LOGERR(("ImageSaveManager::Save3DImage - invalid width/height/depth on image"));
return false;
}
//Get the basic type of this texture (RGB,depth etc)
GLenum baseTextureFormat;
if(!GetBaseTextureFormat(glType,baseTextureFormat))
{
return false;
}
// Layout 2D array images in a different order to 3D images (vertically - so each image is stored correctly)
GLint layoutWidth = width*depth;
GLint layoutHeight = height;
if(glType == GL_TEXTURE_2D_ARRAY)
{
layoutWidth = width;
layoutHeight = height*depth;
}
//Create a new image to write to
corona::Image * newImage = corona::CreateImage(layoutWidth,layoutHeight,corona::PF_R8G8B8A8);
if(!newImage)
{
return false;
}
//Set the required pack operations
GLV.glPixelStorei(GL_PACK_IMAGE_HEIGHT,height);
GLV.glPixelStorei(GL_PACK_ROW_LENGTH, width);
//Fill the image buffer
RetrieveImageData(glType, baseTextureFormat, newImage);
//Write the image out
if(!WriteImageFile(fileName,newImage,retFileNames))
{
delete newImage;
return false;
}
//Write an icon version (can fail if icon writing is not enabled)
WriteImageIconFile(fileName,newImage,retFileNames);
//Clean up
delete newImage;
return true;
}
int main(int argc, char *argv[])
{
int n, p, row, col, nRows, nCols, imgPlanes, codingPlanes, fileSize,
targetBytes, deltaNum, deltaDen, maxCount, plane;
double decodedFraction = 1;
char progressIndicator = 'y', verbose = 'n';
unsigned int outFile = 0;
Image *recImg;
FILE *fpInp;
CModel *cModel;
CTemplate *cTemplateIntra = InitTemplate(TEMPLATE_INTRA);
CTemplate *cTemplateInter = InitTemplate(TEMPLATE_INTER);
PModel *pModel;
CPattern *cPattern;
if(argc == 1)
{
fprintf(stderr, "Usage: %10s [ -f decodedFraction ]\n", argv[0]);
//fprintf(stderr,"Usage: Micro3DDec [ -f decodedFraction ]\n");
//fprintf(stderr," [ -nopi (no progress indicator) ]\n");
fprintf(stderr," [ -v (verbose) ]\n");
fprintf(stderr," [ -o outputFile ]\n");
fprintf(stderr," codeFile\n");
return EXIT_FAILURE;
}
for(n = 1 ; n < argc ; n++)
if(!strcmp("-f", argv[n]))
{
decodedFraction = atof(argv[n+1]);
break;
}
for(n = 1 ; n < argc ; n++)
if(!strcmp("-nopi", argv[n]))
{
progressIndicator = 'n';
break;
}
for(n = 1 ; n < argc ; n++)
if(!strcmp("-v", argv[n]))
{
verbose = 'y';
progressIndicator = 'n';
break;
}
for(n = 1 ; n < argc ; n++)
if(!strcmp("-o", argv[n]))
{
outFile = n+1;
break;
}
if(!(fpInp = fopen(argv[argc - 1], "r")))
{
fprintf(stderr, "Error: couldn't open code file\n");
return 1;
}
fseek(fpInp, 0, SEEK_END);
fileSize = ftell(fpInp);
rewind(fpInp);
printf("Code file has %d bytes\n", fileSize);
targetBytes = (int)(fileSize * decodedFraction + 0.5);
if(fileSize != targetBytes)
printf("Decoding the first %d bytes\n", targetBytes);
startinputtingbits();
start_decode(fpInp);
/* Get the number of rows and cols */
nRows = ReadNBits(STORAGE_BITS_N_ROWS, fpInp);
nCols = ReadNBits(STORAGE_BITS_N_COLS, fpInp);
/* Get the number of image bit-planes (1..16) */
imgPlanes = ReadNBits(STORAGE_BITS_N_IMG_PLANES, fpInp) + 1;
/* Get the number of encoded bit-planes (1..16) */
codingPlanes = ReadNBits(STORAGE_BITS_N_COD_PLANES, fpInp) + 1;
deltaNum = ReadNBits(STORAGE_BITS_PMODEL_DELTA_NUM, fpInp) + 1;
deltaDen = ReadNBits(STORAGE_BITS_PMODEL_DELTA_DEN, fpInp) + 1;
maxCount = ReadNBits(STORAGE_BITS_PMODEL_MAX_COUNT, fpInp);
if(maxCount == 0 || maxCount > DEFAULT_PMODEL_MAX_COUNT)
fprintf(stderr, "Warning (maxCount): counters may overflow\n");
printf("Image has %d rows, %d cols and %d bit-planes\n", nRows,
nCols, imgPlanes);
printf("Decoding the %d most significant bit-planes)\n", codingPlanes);
printf("Delta: %d/%d, MaxCount: %d\n", deltaNum, deltaDen, maxCount);
if(!(recImg = CreateImage(nRows, nCols, imgPlanes <= 8 ?
DATA_TYPE_C : DATA_TYPE_S, 1)))
return EXIT_FAILURE;
if(verbose == 'y')
{
printf("Using intra template:\n\n");
ShowTemplate(cTemplateIntra);
putchar('\n');
printf("Using inter template:\n\n");
ShowTemplate(cTemplateInter);
putchar('\n');
}
cModel = CreateCModel(TEMPLATE_MAX_SIZE, N_SYMBOLS, N_CTX_SYMBOLS,
deltaNum, deltaDen, maxCount);
pModel = CreatePModel(N_SYMBOLS);
cPattern = CreateCPattern(imgPlanes, MAX(cTemplateIntra->size,
cTemplateInter->size));
for(plane = imgPlanes - 1 ; plane >= imgPlanes - codingPlanes ; plane--)
{
/* Get the context pattern for this bit-plane */
for(p = plane ; p < imgPlanes ; p++)
{
cPattern->size[p] = 0;
for(n = 0 ; n < (p == plane ? cTemplateIntra->size :
cTemplateInter->size) ; n++)
if((cPattern->pattern[p][n] = ReadNBits(1, fpInp)))
cPattern->size[p]++;
}
if(verbose == 'y')
{
fprintf(stderr, "Plane %2d: ", plane);
for(n = plane ; n < imgPlanes ; n++)
fprintf(stderr, "%d ", cPattern->size[n]);
fprintf(stderr, "\n");
}
DecodeBitPlane(recImg, imgPlanes, plane, cModel, cTemplateIntra,
cTemplateInter, pModel, cPattern, fpInp, targetBytes);
if(_bytes_input > targetBytes)
break;
if(progressIndicator == 'y')
fprintf(stderr, "Plane %2d decoded\n", plane);
}
for(plane = imgPlanes - codingPlanes - 1 ; plane >= 0 ; plane--)
for(row = 0 ; row < recImg->nRows ; row++)
for(col = 0 ; col < recImg->nCols ; col++)
if(_bytes_input <= targetBytes)
PutGrayPixel(recImg, row, col, GetGrayPixel(recImg,
row, col) | (ReadNBits(1, fpInp) << plane));
//printf("Decoded %llu bytes\n", _bytes_input);
printf("Decoded %"PRIu64" bytes\n", (uint64_t)_bytes_input);
finish_decode();
doneinputtingbits();
fclose(fpInp);
if ((outFile > 0) && (outFile < argc))
WriteImageFile(argv[outFile], recImg);
else
WriteImageFile("!decMicroImg09.pgm", recImg);
putchar('\n');
return EXIT_SUCCESS;
}
