bool HdrInput::read_native_scanline (int y, int z, void *data) { if (m_next_scanline > y) { // User is trying to read an earlier scanline than the one we're // up to. Easy fix: close the file and re-open. ImageSpec dummyspec; int subimage = current_subimage(); int miplevel = current_miplevel(); if (! close () || ! open (m_filename, dummyspec) || ! seek_subimage (subimage, miplevel, dummyspec)) return false; // Somehow, the re-open failed assert (m_next_scanline == 0 && current_subimage() == subimage && current_miplevel() == miplevel); } while (m_next_scanline <= y) { // Keep reading until we're read the scanline we really need int r = RGBE_ReadPixels_RLE (m_fd, (float *)data, m_spec.width, 1, rgbe_error); ++m_next_scanline; if (r != RGBE_RETURN_SUCCESS) { error ("%s", rgbe_error); return false; } } return true; }
void HDRTextureCube::Load(const string fileName) { string path = string(HDR_RELATIVE_PATH) + fileName + string(HDR_EXT); cout << "Loading hdr texture " << path << ".." << endl; FILE* file = fopen(path.c_str(), "rb"); RGBE_ReadHeader(file, &width, &height, NULL); data = new float[3 * width * height]; RGBE_ReadPixels_RLE(file, data, width, height); fclose(file); LoadFaces(); cout << " - width : " << width << "px" << endl; cout << " - height : " << height << "px" << endl; cout << " - memory size : " << (3 * width * height * sizeof(float)) / 8 << " bytes" << endl; cout << "Generating texture cube.." << endl; }
bool readHDR(const char* path, cv::Mat& hdr) { FILE* fp = std::fopen(path, "rb"); if (!fp) { std::fprintf(stderr, "cannot load %s\n", path); return false; } rgbe_header_info info; int rgbeStatus, width, height; rgbeStatus = RGBE_ReadHeader(fp, &width, &height, &info); if (rgbeStatus != RGBE_RETURN_SUCCESS) { std::fclose(fp); return false; } cv::Mat_<cv::Vec3f> tmp(height, width); float* data = (float*)static_cast<void*>(tmp.ptr()); rgbeStatus = RGBE_ReadPixels_RLE(fp, data, width, height); if (rgbeStatus != RGBE_RETURN_SUCCESS) { std::fclose(fp); return false; } for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) { cv::Vec3f& c = tmp.at<cv::Vec3f>(y, x); std::swap(c[0], c[2]); } } std::fclose(fp); hdr = tmp; return true; }
void Image::loadFromHdr(const std::string &filename) { // Try to open the file FILE* f = fopen(filename.c_str(), "rb"); if (f == 0) throw Exception("File missing : " + filename); // Read image header int res = RGBE_ReadHeader(f, &sizeX, &sizeY, 0); if (res < 0) throw Exception("Incorrect .hdr file : " + filename); // Read image data data = new uchar[sizeof(float)*3*sizeX*sizeY]; res = RGBE_ReadPixels_RLE(f, reinterpret_cast<float*>(data), sizeX, sizeY); // Set format and type format = GL_RGB; type = GL_FLOAT; // Close the file fclose(f); }
int main(int argc, const char **argv) { FILE *fp; int width, height; struct MipOutput *mip; struct FrameBuffer *hdr; rgbe_header_info info; if (argc == 2 && strcmp(argv[1], "--help") == 0) { printf("%s", USAGE); return 0; } if (argc != 3) { fprintf(stderr, "error: invalid number of arguments.\n"); fprintf(stderr, "%s", USAGE); return -1; } errno = 0; if ((fp = fopen(argv[1], "rb")) == NULL) { fprintf(stderr, "error: %s: %s\n", argv[1], strerror(errno)); return -1; } RGBE_ReadHeader(fp, &width, &height, &info); if (width <= 0 || height <= 0) { fprintf(stderr, "error: invalid image size detected: %d x %d\n", width, height); return -1; } hdr = FbNew(); if (hdr == NULL) { fprintf(stderr, "error: could not allocate framebuffer itself\n"); return -1; } if (FbResize(hdr, width, height, 3) == NULL) { fprintf(stderr, "error: could not allocate framebuffer: %d x %d\n", width, height); return -1; } RGBE_ReadPixels_RLE(fp, FbGetWritable(hdr, 0, 0, 0), width, height); if ((mip = MipOpenOutputFile(argv[2])) == NULL) { fprintf(stderr, "error: couldn't open output file\n"); FbFree(hdr); return -1; } MipGenerateFromSourceData(mip, FbGetReadOnly(hdr, 0, 0, 0), width, height, 3); printf("input res: %d, %d\n", width, height); printf("output res: %d, %d\n", mip->width, mip->height); MipWriteFile(mip); MipCloseOutputFile(mip); FbFree(hdr); fclose(fp); return 0; }
bool CDX9TextureObject::LoadHDRFile( TCHAR * file ) { LPDIRECT3DDEVICE9 pDevice; if( !m_Renderer ) { return false; } pDevice = (LPDIRECT3DDEVICE9)m_Renderer->GetAPIDevice(); if( !pDevice ) { return false; } int iWidth; int iHeight; // Read in the HDR light probe. FILE* fp = fopen( file, "rb" ); if( fp ) { rgbe_header_info info; RGBE_ReadHeader( fp, &iWidth, &iHeight, &info ); // We really don't need this float fExposure = info.exposure; float fGamma = info.gamma; // Create a float array to read in the RGB components float* m_fHDRPixels = new float[3 * iWidth * iHeight]; memset( m_fHDRPixels, 0, 3 * iWidth * iHeight * sizeof( float ) ); RGBE_ReadPixels_RLE( fp, m_fHDRPixels, iWidth, iHeight ); if( FAILED( D3DXCreateTexture( pDevice, iWidth, iHeight, 1, 0, D3DFMT_A16B16G16R16F, D3DPOOL_MANAGED, &m_Texture ) ) ) { m_ToolBox->Log( LOGERROR, _T("Could not load radience(.hdr) file\n") ); return false; } // Convert the 32-bit floats into 16-bit floats and include the alpha component D3DXFLOAT16* m_fHDR = new D3DXFLOAT16[4 * iWidth * iHeight]; int j = 0; for( int i = 0; i < 4 * iWidth * iHeight; i += 4 ) { m_fHDR[i] = m_fHDRPixels[i - j]; m_fHDR[i + 1] = m_fHDRPixels[i + 1 - j]; m_fHDR[i + 2] = m_fHDRPixels[i + 2 - j]; m_fHDR[i + 3] = 1.0f; j++; } // Lock the texture and copy the pixel data into it D3DLOCKED_RECT lr; if(FAILED( m_Texture->LockRect( 0, &lr, NULL, 0 ) ) ) { m_ToolBox->Log( LOGERROR, _T("Could not lock radience(.hdr) file for writing\n") ); return false; } memcpy( (D3DXFLOAT16*)lr.pBits, m_fHDR, 4 * iWidth * iHeight * sizeof( D3DXFLOAT16 ) ); if(FAILED( m_Texture->UnlockRect( 0 ) ) ) { m_ToolBox->Log( LOGERROR, _T("Could not unlock radience(.hdr) file for writing\n") ); return false; } delete[] m_fHDRPixels; delete[] m_fHDR; fclose( fp ); if( m_Texture ) { m_Texture = m_Texture; m_Filename = file; m_bRenderTarget = false; D3DSURFACE_DESC tempDesc; m_Texture->GetLevelDesc(0, &tempDesc); if( m_AutoGenMips ) { m_Texture->GenerateMipSubLevels(); } m_Width = tempDesc.Width; m_Height = tempDesc.Height; m_ColorDepth = 64; return true; } } return false; }
int RD(FILE* fp, float *data, int width, int height, char *errbuf) { return RGBE_ReadPixels_RLE(fp, data, width, height, errbuf); }