/* Exports the left and right eye view as images */
void exportImage(void) {
unsigned char *image;
image = (unsigned char*)malloc((3*Settings::pixelWidth*Settings::pixelHeight)*sizeof(char));
glPixelStorei(GL_PACK_ALIGNMENT,1);
// Left Image
glReadBuffer(GL_BACK_LEFT);
glReadPixels(0, 0, (int)Settings::pixelWidth, (int)Settings::pixelHeight,
GL_BGR,GL_UNSIGNED_BYTE, image);
FIBITMAP* leftImage = FreeImage_ConvertFromRawBits(image, (int)Settings::pixelWidth,
(int)Settings::pixelHeight,
3*Settings::pixelWidth, 24, 0xFF0000,
0x00FF00, 0x0000FF, false);
FreeImage_Save(FIF_BMP, leftImage, "left.bmp", 0);
// Right image
glReadBuffer(GL_BACK_RIGHT);
glReadPixels(0, 0, (int)Settings::pixelWidth, (int)Settings::pixelHeight,
GL_BGR, GL_UNSIGNED_BYTE, image);
FIBITMAP* rightImage = FreeImage_ConvertFromRawBits(image, (int)Settings::pixelWidth,
(int)Settings::pixelHeight,
3*Settings::pixelWidth, 24, 0xFF0000,
0x00FF00, 0x0000FF, false);
FreeImage_Save(FIF_BMP, rightImage, "right.bmp", 0);
free(image);
}
bool process_image(std::string infile, std::string outfile, double brightness, double gamma)
{
DIR *editdir = opendir("img/edit");
struct dirent *file;
while ((file = readdir(editdir)) != NULL)
{
if (strcmp(file -> d_name, outfile.c_str()) == 0)
{
return false;
}
}
closedir(editdir);
infile = "img/" + infile;
outfile = "img/edit/" + outfile;
FIBITMAP *input = FreeImage_Load(FIF_PNG, infile.c_str());
if (input == NULL)
{
std::cerr << "Failed to load " << infile << std::endl;
exit(1);
}
if (!FreeImage_Save(FIF_PNG, input, outfile.c_str()))
{
FreeImage_Unload(input);
std::cerr << "Failed to save " << outfile << std::endl;
exit(1);
}
FreeImage_Unload(input);
FIBITMAP *output = FreeImage_Load(FIF_PNG, outfile.c_str());
if (output == NULL)
{
std::cerr << "Failed to load " << outfile << std::endl;
exit(1);
}
unsigned int img_w = FreeImage_GetWidth(output);
unsigned int img_h = FreeImage_GetHeight(output);
RGBQUAD pixel;
for (unsigned int x = 0; x < img_w; x++)
{
for (unsigned int y = 0; y < img_h; y++)
{
FreeImage_GetPixelColor(output, x, y, &pixel);
pixel.rgbRed = int(clamp(0, pixel.rgbRed * brightness, 255));
pixel.rgbBlue = int(clamp(0, pixel.rgbBlue * brightness, 255));
pixel.rgbGreen = int(clamp(0, pixel.rgbGreen * brightness, 255));
pixel.rgbRed = int(clamp(0, pow(((double) pixel.rgbRed) / 255.0f, gamma) * 255.0, 255));
pixel.rgbBlue = int(clamp(0, pow(((double) pixel.rgbBlue) / 255.0f, gamma) * 255.0, 255));
pixel.rgbGreen = int(clamp(0, pow(((double) pixel.rgbGreen) / 255.0f, gamma) * 255.0, 255));
FreeImage_SetPixelColor(output, x, y, &pixel);
}
}
if (!FreeImage_Save(FIF_PNG, output, outfile.c_str()))
{
FreeImage_Unload(input);
std::cerr << "Failed to save " << outfile << std::endl;
exit(1);
}
FreeImage_Unload(output);
return true;
}
void storeFreeImage(const Ref<Image>& img, const FileName& fileName)
{
FIBITMAP* dib = FreeImage_Allocate((int)img->width, (int)img->height, 24);
for(size_t y = 0; y < img->height; y++)
{
for(size_t x = 0; x < img->width; x++)
{
Color4 c = img->get(x, y);
RGBQUAD Value = {0};
Value.rgbRed = (BYTE)(clamp(c.r) * 255.0f);
Value.rgbGreen = (BYTE)(clamp(c.g) * 255.0f);
Value.rgbBlue = (BYTE)(clamp(c.b) * 255.0f);
FreeImage_SetPixelColor(dib, (unsigned int)x, (unsigned int)y, &Value);
}
}
FIBITMAP* fiLogo = loadWatermark();
unsigned int LogoWidth = FreeImage_GetWidth (fiLogo);
unsigned int LogoHeight = FreeImage_GetHeight(fiLogo);
if(LogoWidth > img->width || LogoHeight > img->height)
{
FreeImage_Unload(fiLogo);
FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(fileName.c_str());
if(FreeImage_FIFSupportsWriting(fif))
FreeImage_Save(fif, dib, fileName.c_str());
FreeImage_Unload(dib);
}
else
{
int x_pos = (int)img->width - LogoWidth;
int y_pos = (int)img->height - LogoHeight;
FIBITMAP* fiFG = FreeImage_Allocate((int)img->width, (int)img->height, 32);
BOOL b = FreeImage_Paste(fiFG, fiLogo, x_pos, y_pos, 255);
FreeImage_Unload(fiLogo);
FIBITMAP* fiNew = FreeImage_Composite(fiFG, FALSE, NULL, dib);
FreeImage_Unload(dib);
FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(fileName.c_str());
int save_flags = 0;
if(fif == FIF_JPEG)
save_flags = JPEG_QUALITYSUPERB | JPEG_BASELINE | JPEG_OPTIMIZE;
if(FreeImage_FIFSupportsWriting(fif))
FreeImage_Save(fif, fiNew, fileName.c_str(), save_flags);
FreeImage_Unload(fiNew);
}
}
//----------------------------------------------------------------
void ofImage::saveImageFromPixels(string fileName, ofPixels &pix){
if (pix.bAllocated == false){
ofLog(OF_LOG_ERROR,"error saving image - pixels aren't allocated");
return;
}
#ifdef TARGET_LITTLE_ENDIAN
if (pix.bytesPerPixel != 1) swapRgb(pix);
#endif
FIBITMAP * bmp = getBmpFromPixels(pix);
#ifdef TARGET_LITTLE_ENDIAN
if (pix.bytesPerPixel != 1) swapRgb(pix);
#endif
fileName = ofToDataPath(fileName);
if (pix.bAllocated == true){
FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
fif = FreeImage_GetFileType(fileName.c_str(), 0);
if(fif == FIF_UNKNOWN) {
// or guess via filename
fif = FreeImage_GetFIFFromFilename(fileName.c_str());
}
if((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) {
FreeImage_Save(fif, bmp, fileName.c_str(), 0);
}
}
if (bmp != NULL){
FreeImage_Unload(bmp);
}
}
bool SaveTextureToFile(const char* filename, const void* data, int w, int h)
{
bool ret = false;
FIBITMAP* bitmap = nullptr;
bitmap = FreeImage_AllocateT(FIT_BITMAP, w, h, 32);
CHECK(bitmap);
RGBQUAD dst;
const Color* imageData = (const Color*)data;
for (int y = 0; y < h; ++y)
{
for (int x = 0; x < w; ++x)
{
const Color& src = imageData[((h - 1 - y) * w + x)];
dst.rgbBlue = (BYTE)(src.b * 255);
dst.rgbGreen = (BYTE)(src.g * 255);
dst.rgbRed = (BYTE)(src.r * 255);
dst.rgbReserved = 255;
CHECK(FreeImage_SetPixelColor(bitmap, x, y, &dst));
}
}
CHECK(FreeImage_Save(FIF_BMP, bitmap, filename, BMP_DEFAULT));
ret = true;
Exit0:
if (bitmap)
FreeImage_Unload(bitmap);
return ret;
}
static int
write_img(char *name, const greyscale_image *img) {
FIBITMAP *image;
RGBQUAD aPixel;
int i,j;
image = FreeImage_Allocate(img->width, img->height, 24, 0, 0, 0);
if(!image) {
perror("FreeImage_Allocate");
return -1;
}
for(i = 0; i < img->height; i++) {
for(j = 0; j < img->width; j++) {
float v = img->v[i*img->width + j];
if (v > 1.0) v = 1.0;
else if (v < 0) v = 0.0;
v *= 255.0;
aPixel.rgbRed = (unsigned char) v;
aPixel.rgbGreen = (unsigned char) v;
aPixel.rgbBlue = (unsigned char) v;
FreeImage_SetPixelColor(image, j, i, &aPixel);
}
}
if(!FreeImage_Save(FIF_JPEG, image, name, 0)) {
perror("FreeImage_Save");
}
FreeImage_Unload(image);
return 0;
}
void write_image(const string& file, const SampleBuffer& buffer)
{
const float samples = static_cast<float>(buffer.samples());
FIBITMAP* dib = FreeImage_Allocate(buffer.width(), buffer.height(),
32, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);
const unsigned int BYTESPP =
FreeImage_GetLine(dib) / FreeImage_GetWidth(dib);
for (unsigned int y = 0; y < FreeImage_GetHeight(dib); ++y) {
BYTE* bits = FreeImage_GetScanLine(dib, y);
for (unsigned int x = 0; x < FreeImage_GetWidth(dib); ++x) {
vec3 c = gamma_correct(buffer.get(x, y) / samples) * 255.0f;
bits[FI_RGBA_RED] = static_cast<BYTE>(c.r);
bits[FI_RGBA_GREEN] = static_cast<BYTE>(c.g);
bits[FI_RGBA_BLUE] = static_cast<BYTE>(c.b);
bits[FI_RGBA_ALPHA] = 255;
bits += BYTESPP;
}
}
if (!FreeImage_Save(FIF_PNG, dib, file.c_str(), 0)) {
string err = "Failed to save screenshot to file '";
err += file;
err += '\'';
throw err;
}
FreeImage_Unload(dib);
}
void test32BitsChannels(unsigned width, unsigned height) {
BOOL bResult = FALSE;
// create a test 8-bit image
FIBITMAP *src = createZonePlateImage(width, height, 128);
if(src != NULL) {
// convert to 32-bit
FIBITMAP *tmp = FreeImage_ConvertTo32Bits(src);
FreeImage_Unload(src);
src = tmp;
}
assert(src != NULL);
// save for further examination
bResult = FreeImage_Save(FIF_PNG, src, "zoneplate.png", PNG_DEFAULT);
assert(bResult);
// test get/set channel
// -------------------------
FIBITMAP *channel = FreeImage_GetChannel(src, FICC_ALPHA);
assert(channel != NULL);
bResult = FreeImage_SetChannel(src, channel, FICC_ALPHA);
assert(bResult);
FreeImage_Unload(channel);
FreeImage_Unload(src);
}
BOOL fipImage::save(const char* lpszPathName, int flag) const {
FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
BOOL bSuccess = FALSE;
// Try to guess the file format from the file extension
fif = FreeImage_GetFIFFromFilename(lpszPathName);
if(fif != FIF_UNKNOWN ) {
// Check that the dib can be saved in this format
BOOL bCanSave;
FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(_dib);
if(image_type == FIT_BITMAP) {
// standard bitmap type
WORD bpp = FreeImage_GetBPP(_dib);
bCanSave = (FreeImage_FIFSupportsWriting(fif) && FreeImage_FIFSupportsExportBPP(fif, bpp));
} else {
// special bitmap type
bCanSave = FreeImage_FIFSupportsExportType(fif, image_type);
}
if(bCanSave) {
bSuccess = FreeImage_Save(fif, _dib, lpszPathName, flag);
return bSuccess;
}
}
return bSuccess;
}
/** Generic image writer
@param dib Pointer to the dib to be saved
@param lpszPathName Pointer to the full file name
@param flag Optional save flag constant
@return Returns true if successful, returns false otherwise
*/
bool GenericWriter(const bitmap_ptr& dib, const std::string& lpszPathName, int flag) {
auto fif = FIF_UNKNOWN;
auto bSuccess = FALSE;
// check if file path is not empty
if (lpszPathName.empty())
return false;
if (dib) {
// try to guess the file format from the file extension
fif = FreeImage_GetFIFFromFilename(lpszPathName.c_str());
if (fif != FIF_UNKNOWN) {
// check that the plugin has sufficient writing and export capabilities ...
if (FreeImage_FIFSupportsWriting(fif) && FreeImage_FIFSupportsExportType(fif, FreeImage_GetImageType(dib.get()))) {
// ok, we can save the file
bSuccess = FreeImage_Save(fif, dib.get(), lpszPathName.c_str(), flag);
// unless an abnormal bug, we are done !
}
else {
std::cout << "Can't save file" << lpszPathName << std::endl;
}
}
else {
std::cerr << "Can't determine output file type" << std::endl;
}
}
return (bSuccess == TRUE);
}
bool ZitexConverter::convert(const QString & inFileName, const ConfigDao & configuration)
{
auto inFileNameStdStr = inFileName.toStdString();
Zitex::Reader reader;
Zitex::Reader::Data data;
reader.readFromFile(inFileNameStdStr, data);
for (uint32_t it = 0; it < data.header->texImagesNum; ++it)
{
Zitex::TexImageHeader * texImageHeader = data.texImages[it].header;
if (texImageHeader->level == 0)
{
auto width = texImageHeader->width;
auto height = texImageHeader->height;
FIBITMAP * fiBitmap = FreeImage_Allocate(width, height, 32);
squish::DecompressImage(FreeImage_GetBits(fiBitmap), width, height, data.texImages[it].data,
data.header->squishFlags);
// section(".", 0, -2) copyes from begin to 2nd section from end.
// The first section from end is the extension
std::string outFileNameStdStr = inFileName.section(".", 0, -2).append(".png").toStdString();
FreeImage_FlipVertical(fiBitmap);
FreeImage_Save(FIF_PNG, fiBitmap, outFileNameStdStr.c_str());
FreeImage_Unload(fiBitmap);
}
}
}
bool RGBAImage::WriteToFile(const char* filename)
{
const FREE_IMAGE_FORMAT fileType = FreeImage_GetFIFFromFilename(filename);
if(FIF_UNKNOWN == fileType)
{
printf("Can't save to unknown filetype %s\n", filename);
return false;
}
FIBITMAP* bitmap = FreeImage_Allocate(Width, Height, 32, 0x000000ff, 0x0000ff00, 0x00ff0000);
if(!bitmap)
{
printf("Failed to create freeimage for %s\n", filename);
return false;
}
const unsigned int* source = Data;
for( int y=0; y < Height; y++, source += Width )
{
unsigned int* scanline = (unsigned int*)FreeImage_GetScanLine(bitmap, Height - y - 1 );
memcpy(scanline, source, sizeof(source[0]) * Width);
}
FreeImage_SetTransparent(bitmap, true);
FIBITMAP* converted = FreeImage_ConvertTo24Bits(bitmap);
const bool result = !!FreeImage_Save(fileType, converted, filename);
if(!result)
printf("Failed to save to %s\n", filename);
FreeImage_Unload(converted);
FreeImage_Unload(bitmap);
return result;
}
void Film::output(string path){
int maxIntensity = 255;
int bpp = 24;
RGBQUAD color;
FreeImage_Initialise();
FIBITMAP* bitmap = FreeImage_Allocate(sceneWidth,
sceneHeight,
bpp);
for(int h = 0; h < sceneHeight; h++){
vector<Color> row = pixelData[h];
for(int w = 0; w < sceneWidth; w++){
Color pixelColor = row[w];
color.rgbRed = pixelColor.getR() * maxIntensity;
color.rgbGreen = pixelColor.getG() * maxIntensity;
color.rgbBlue = pixelColor.getB() * maxIntensity;
FreeImage_SetPixelColor(bitmap, w, h, &color);
}
}
if (FreeImage_Save(FIF_PNG, bitmap, path.c_str(), 0)) {
cout << "Image saved to " << path << endl;
cout << sceneWidth << endl;
}
else {
cerr << "Couldn't save image to " << path << endl;
exit(1);
}
FreeImage_DeInitialise();
}
void pre_lzw::do_lzw(const QDir & d){
FreeImage_Initialise(true);
QString label_out = "";
QString dst = ui.lineEdit_2->text();
QString d_src = d.path();
QString serial_str = d_src.right(5);
QDir dst_dir(dst);
dst_dir.mkdir(serial_str);
QString image_name = "", image_name_path(""), saved_name("");
int dot_pos = 0;
QFileInfoList handled_images = d.entryInfoList();
QList<QFileInfo>::iterator images_iter = handled_images.begin();
FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
for(; images_iter < handled_images.end(); ++images_iter){
image_name_path = (*images_iter).absoluteFilePath();
if((*images_iter).isDir()){
continue;
}
FIBITMAP *handled_image = 0;
image_name = (*images_iter).fileName();
dot_pos = image_name.indexOf(".");
saved_name = dst + "\\" + serial_str + "\\" + image_name.left(dot_pos) + "_c.tif";
label_out += saved_name + "\n";
fif = FreeImage_GetFileType(image_name_path.toStdString().c_str());
handled_image = FreeImage_Load(fif, image_name_path.toStdString().c_str());
FreeImage_Save(FIF_TIFF, handled_image, saved_name.toStdString().c_str(), TIFF_LZW);
FreeImage_Unload(handled_image);
}
// ui.label->setText(label_out);
FreeImage_DeInitialise();
}
/**
Test loading from a buffer attached to a memory stream
*/
void testLoadMemIO(const char *lpszPathName) {
struct stat buf;
int result;
// get data associated with lpszPathName
result = stat(lpszPathName, &buf);
if(result == 0) {
// allocate a memory buffer and load temporary data
BYTE *mem_buffer = (BYTE*)malloc(buf.st_size * sizeof(BYTE));
if(mem_buffer) {
FILE *stream = fopen(lpszPathName, "rb");
if(stream) {
fread(mem_buffer, sizeof(BYTE), buf.st_size, stream);
fclose(stream);
// attach the binary data to a memory stream
fipMemoryIO memIO(mem_buffer, buf.st_size);
// get the file type
FREE_IMAGE_FORMAT fif = memIO.getFileType();
// load an image from the memory stream
FIBITMAP *check = memIO.read(fif, PNG_DEFAULT);
// save as a regular file
FreeImage_Save(FIF_PNG, check, "blob.png", PNG_DEFAULT);
// close the stream (memIO is destroyed)
}
// user is responsible for freeing the data
free(mem_buffer);
}
}
}
//----------------------------------------------------------------
void ofSaveImage(ofPixels & pix, string fileName, ofImageQualityType qualityLevel) {
if (pix.isAllocated() == false){
ofLog(OF_LOG_ERROR,"error saving image - pixels aren't allocated");
return;
}
#ifdef TARGET_LITTLE_ENDIAN
pix.swapRgb();
#endif
FIBITMAP * bmp = getBmpFromPixels(pix);
#ifdef TARGET_LITTLE_ENDIAN
pix.swapRgb();
#endif
fileName = ofToDataPath(fileName);
FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;
fif = FreeImage_GetFileType(fileName.c_str(), 0);
if(fif == FIF_UNKNOWN) {
// or guess via filename
fif = FreeImage_GetFIFFromFilename(fileName.c_str());
}
if((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) {
if(fif == FIF_JPEG) {
int quality = JPEG_QUALITYSUPERB;
switch(qualityLevel) {
case OF_IMAGE_QUALITY_WORST: quality = JPEG_QUALITYBAD; break;
case OF_IMAGE_QUALITY_LOW: quality = JPEG_QUALITYAVERAGE; break;
case OF_IMAGE_QUALITY_MEDIUM: quality = JPEG_QUALITYNORMAL; break;
case OF_IMAGE_QUALITY_HIGH: quality = JPEG_QUALITYGOOD; break;
case OF_IMAGE_QUALITY_BEST: quality = JPEG_QUALITYSUPERB; break;
}
FreeImage_Save(fif, bmp, fileName.c_str(), quality);
} else {
if(qualityLevel != OF_IMAGE_QUALITY_BEST) {
ofLog(OF_LOG_WARNING, "ofImageCompressionType only applies to JPEG images, ignoring value.");
}
FreeImage_Save(fif, bmp, fileName.c_str());
}
}
if (bmp != NULL){
FreeImage_Unload(bmp);
}
}
///
// Save an image using the FreeImage library
//
bool SaveImage(char *fileName, char *buffer, int width, int height)
{
FREE_IMAGE_FORMAT format = FreeImage_GetFIFFromFilename(fileName);
FIBITMAP *image = FreeImage_ConvertFromRawBits((BYTE*)buffer, width,
height, width * 4, 32,
0xFF000000, 0x00FF0000, 0x0000FF00);
return (FreeImage_Save(format, image, fileName) == TRUE) ? true : false;
}
void rtgu::image_io::write_image(char const* filename, any_image const& image)
{
FREE_IMAGE_FORMAT fi_image_format = FreeImage_GetFIFFromFilename(filename);
FIBITMAP* fi_image = detail::get_FIBITMAP(image);
BOOL result = FreeImage_Save(fi_image_format, fi_image, filename);
}
//---------------------------------------------------------------------
void FreeImageCodec::codeToFile(MemoryDataStreamPtr& input,
const String& outFileName, Codec::CodecDataPtr& pData) const
{
FIBITMAP* fiBitmap = encode(input, pData);
FreeImage_Save((FREE_IMAGE_FORMAT)mFreeImageType, fiBitmap, outFileName.c_str());
FreeImage_Unload(fiBitmap);
}
void ImagePNG::save(std::string name)
{
std::string filename = name+".png";
if(bitmap != nullptr)
{
FreeImage_Save(FIF_PNG,bitmap,filename.c_str(),0);
}
}
/**
* This method saves the image to an given file.
* The image type will determined by the file ending.
*
* @param szFile the path of the image file to save
* @return true if the image data was saved, else false
*/
bool fipImage::save( const char * szFile ) const{
FREE_IMAGE_FORMAT freeImageFormat = FreeImage_GetFIFFromFilename( szFile );
if ( freeImageFormat == FIF_UNKNOWN ){
return false;
}
return FreeImage_Save( freeImageFormat, pImageData, szFile);
}
int main(int argc, char** argv)
{
int winx = 1920;
int winy = 1080;
glfwInit();
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
GLFWwindow* window = glfwCreateWindow(winx, winy, "IGS View GLFW", NULL, NULL);
if (!window) {
glfwTerminate();
return -1;
}
glfwSetKeyCallback(window, glfw_key);
glfwSetMouseButtonCallback(window, glfw_mousebutton);
glfwSetCursorPosCallback(window, glfw_motion);
/* Make the window's context current */
glfwMakeContextCurrent(window);
glewExperimental = true;
glewInit();
the_app = std::make_shared<application>(argc, argv, winx, winy);
bool result_feedback = false;
/* Loop until the user closes the window */
while (!glfwWindowShouldClose(window))
{
glut_display();
#if 1
if (!result_feedback) {
std::vector<std::array<uint8_t, 3>> data(winx*winy);
glReadPixels(0, 0, winx, winy, GL_RGB, GL_UNSIGNED_BYTE, &data[0]);
FIBITMAP* image = FreeImage_ConvertFromRawBits((unsigned char*)&data[0], winx, winy, 3 * winx, 24, 0xFF0000, 0x00FF00, 0x0000FF, false);
FreeImage_Save(FIF_BMP, image, "result.bmp", 0);
FreeImage_Unload(image);
result_feedback = true;
}
#endif
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwTerminate();
the_app.reset();
return 0;
}
//you can pass 0 for width or height to keep aspect ratio
bool resizeImage(const std::string& path, int maxWidth, int maxHeight)
{
// nothing to do
if(maxWidth == 0 && maxHeight == 0)
return true;
FREE_IMAGE_FORMAT format = FIF_UNKNOWN;
FIBITMAP* image = NULL;
//detect the filetype
format = FreeImage_GetFileType(path.c_str(), 0);
if(format == FIF_UNKNOWN)
format = FreeImage_GetFIFFromFilename(path.c_str());
if(format == FIF_UNKNOWN)
{
LOG(LogError) << "Error - could not detect filetype for image \"" << path << "\"!";
return false;
}
//make sure we can read this filetype first, then load it
if(FreeImage_FIFSupportsReading(format))
{
image = FreeImage_Load(format, path.c_str());
}else{
LOG(LogError) << "Error - file format reading not supported for image \"" << path << "\"!";
return false;
}
float width = (float)FreeImage_GetWidth(image);
float height = (float)FreeImage_GetHeight(image);
if(maxWidth == 0)
{
maxWidth = (int)((maxHeight / height) * width);
}else if(maxHeight == 0)
{
maxHeight = (int)((maxWidth / width) * height);
}
FIBITMAP* imageRescaled = FreeImage_Rescale(image, maxWidth, maxHeight, FILTER_BILINEAR);
FreeImage_Unload(image);
if(imageRescaled == NULL)
{
LOG(LogError) << "Could not resize image! (not enough memory? invalid bitdepth?)";
return false;
}
bool saved = FreeImage_Save(format, imageRescaled, path.c_str());
FreeImage_Unload(imageRescaled);
if(!saved) {
LOG(LogError) << "Failed to save resized image!";
}
return saved;
}
bool SaveImage(Graphics::TBitmap* picture, AnsiString path, TYPE bit_per_pixel, int flags)
{
FIBITMAP *image = FreeImage_Allocate(picture->Width, picture->Height, 32);
if(!image) return false;
picture->PixelFormat = pf32bit;
if(!WriteImage(image, picture))
{
FreeImage_Unload(image);
return false;
}
AnsiString ext((((AnsiString)ExtractFileExt(path))).UpperCase());
if (ext == ".BMP")
{
if(FreeImage_Save(FIF_BMP, BitrateConversion(image,bit_per_pixel), path.c_str(), BMP_DEFAULT))
{
FreeImage_Unload(image);
return true;
}
}
else if (ext == ".JPG")
{
if(FreeImage_Save(FIF_JPEG, FreeImage_ConvertTo24Bits(image), path.c_str(), flags))
{
FreeImage_Unload(image);
return true;
}
}
else if (ext == ".TIF")
{
if(FreeImage_Save(FIF_TIFF, FreeImage_ConvertTo24Bits(image), path.c_str(), TIFF_DEFAULT))
{
FreeImage_Unload(image);
return true;
}
}
FreeImage_Unload(image);
return false;
}
int main (int argc, char ** argv)
{
if (argc != 2){
printf("you need to give me the number of frames to captures\n");
exit(-1);
}
int num_frames = atoi(argv[1]);
initialize_pru();
start_pru();
FILE * image_data = fopen("/media/usb/image.data", "w");
if (image_data == NULL){
fprintf(stderr, "Failed to open image output file");
exit(-1);
}
const char *version = FreeImage_GetVersion();
printf("Freeimage version %s\n", version);
FIBITMAP* dib = FreeImage_Allocate(320, 203, 16, 0xF800, 0x07E0,0x001F); // allocate 320x203 RGB565 bitmap
int bytespp = FreeImage_GetLine(dib)/FreeImage_GetWidth(dib);
FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
if (image_type == FIT_BITMAP){
printf("1\n");
}
printf("%d %d\n", FreeImage_GetHeight(dib), FreeImage_GetWidth(dib));
BYTE * bits = FreeImage_GetBits(dib);
FILE * fp = fopen("image.data", "rb");
char filename[] = "/root/1314-BeagleBone-Quadcopter/code/ControlTower/ramfs/latest_image.bmp";
int i = 0;
for (i = 0; i < num_frames; i++){
while(i==pruDataMem_int[100]){usleep(100000);}
int buffer = pruDataMem_int[1];
printf("%d buffer=%d\n", pruDataMem_int[100], buffer);
if (i%10==0){
memcpy(bits, pru1_ddr+buffer*320*240*2, 320*203*2);
FreeImage_Save(FIF_BMP, dib, filename,0);
}
}
uninitialize_pru();
fflush(image_data);
printf("%d\n", ((volatile uint8_t *)pru1_ddr)[0]);
fclose(image_data);
prussdrv_pru_disable (PRU_NUM);
prussdrv_exit ();
return(0);
}
void WindowGL::screenshot(std::string filename)
{
unsigned char* buffer = new unsigned char[800 * 600 * 3]; //TODO: dodac sciaganie wymiarow okna z WindowGL
glReadPixels(0, 0, SIZE_W, SIZE_H, GL_BGR, GL_UNSIGNED_BYTE, buffer);
std::cout << "INFO: Saving screen to: " << filename << std::endl;
FIBITMAP * bitmap = FreeImage_ConvertFromRawBits(buffer, SIZE_W, SIZE_H, 800 * 3, 24, 0xFF0000, 0x00FF00, 0x0000FF, false);
FreeImage_Save(FREE_IMAGE_FORMAT::FIF_PNG, bitmap, filename.c_str());
FreeImage_Unload(bitmap);
delete[] buffer;
}
void saveScreenshot(string fname) {
int pix = w * h;
BYTE pixels[3*pix];
glReadBuffer(GL_FRONT);
glReadPixels(0,0,w,h,GL_BGR,GL_UNSIGNED_BYTE, pixels);
FIBITMAP *img = FreeImage_ConvertFromRawBits(pixels, w, h, w * 3, 24, 0xFF0000, 0x00FF00, 0x0000FF, false);
std::cout << "Saving screenshot: " << fname << "\n";
FreeImage_Save(FIF_PNG, img, fname.c_str(), 0);
}
int main(int argc, char* argv[]) {
if (argc != 2) {
cerr << "ERROR: NO INPUT FILE\n";
exit(1);
}
readfile(argv[1]);
Camera camera;
FIBITMAP* bitmap = FreeImage_Allocate(Width, Height, BPP);
Process(bitmap, camera, 8);
FreeImage_Save(FIF_PNG, bitmap, "filename.png", 0);
return 0;
}
void saveScreenshot() {
int pix = windowWidth * windowHeight;
BYTE pixels[3*pix];
glReadBuffer(GL_FRONT);
glReadPixels(0,0,windowWidth,windowHeight,GL_BGR,GL_UNSIGNED_BYTE,pixels);
FIBITMAP *img = FreeImage_ConvertFromRawBits(pixels, windowWidth, windowHeight, windowWidth * 3, 24, 0xFF0000, 0x00FF00, 0x0000FF, false);
std::cout << "Saving screenshot: screenshot.png\n";
FreeImage_Save(FIF_PNG, img, "screenshot.png", 0);
}
void capture()
{
if (doo > 0){ doo = 0; }
else{ doo++; return; }
if (capture_frame >= 250) exit(0);
int mWin_width = 800;
int mWin_height = 600;
// Make the BYTE array, factor of 3 because it's RBG.
BYTE* pixels = new BYTE[3 * mWin_width * mWin_height];
glReadPixels(0, 0, mWin_width, mWin_height, GL_RGB, GL_UNSIGNED_BYTE, pixels);
for (int i = 0; i < mWin_height; i++)
for (int j = 0; j < mWin_width; j++)
{
BYTE tmp = pixels[i*(mWin_width * 3) + (j * 3) + 0];
pixels[i*(mWin_width * 3) + (j * 3) + 0] = pixels[i*(mWin_width * 3) + (j * 3) + 2];
pixels[i*(mWin_width * 3) + (j * 3) + 2] = tmp;
}
// Convert to FreeImage format & save to file
FIBITMAP* image = FreeImage_ConvertFromRawBits(pixels, mWin_width, mWin_height, 3 * mWin_width, 24, 0xFF0000, 0x00FF00, 0x0000FF, false);
char filename[200];
sprintf(filename, "F:/Result_Seen/temp/Image/%05d.png", capture_frame);
capture_frame++;
FreeImage_Save(FIF_PNG, image, filename, 0);
// Free resources
FreeImage_Unload(image);
delete[] pixels;
}
