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; }