void CFontTexCreaterDlg::OnBnClickedExe()
{
CComboBox* ccb = (CComboBox*)GetDlgItem(IDC_COMBO1) ;
if( !ccb )
return ;
// font type
int sel = ccb->GetCurSel() ;
func_setFontInd( g_nFtIns , sel ) ;
// texture size
int texW = 1024 ;
int texH = 1024 ;
CEdit* pEdt = (CEdit*)GetDlgItem( IDC_EDT_TEXTURE_W ) ;
if( pEdt )
{
wchar_t buf[256] ;
pEdt->GetWindowText( buf , 256 ) ;
texW = _wtoi( buf ) ;
}
pEdt = (CEdit*)GetDlgItem( IDC_EDT_TEXTURE_H ) ;
if( pEdt )
{
wchar_t buf[256] ;
pEdt->GetWindowText( buf , 256 ) ;
texH = _wtoi( buf ) ;
}
char *canvas = new char[texW*texH] ;
memset( canvas , 0 , texW*texH ) ;
func_setCanvas( g_nFtIns ,canvas , texW , texH , 0 ) ;
func_drawGlyphFromFile( g_nFtIns , "finalCode.txt" ) ;
//func_drawAllGlyphs( g_nFtIns ) ;
//
{
FreeImage_Initialise() ;
FIBITMAP* bm = FreeImage_Allocate( texW , texH , 24 ) ;
RGBQUAD clr ;
for( int y = 0 ; y < texH ; y ++ )
{
for( int x = 0 ; x < texW ; x ++ )
{
char val = canvas[ y * texW + x ] ;
clr.rgbBlue = val ;
clr.rgbGreen = val ;
clr.rgbRed = val ;
clr.rgbReserved = 255 ;
FreeImage_SetPixelColor( bm , x , texH - 1 - y , &clr ) ;
}
}
//memcpy( bm->data , canvas , texW*texH ) ;
FreeImage_Save( FIF_BMP , bm , "fontTex.bmp" ) ;
FreeImage_Unload( bm ) ;
FreeImage_DeInitialise() ;
}
//
FILE* pf = fopen( "fontBuf" , "wb+" ) ;
fwrite( canvas , texW * texH , 1 , pf ) ;
fclose( pf ) ;
//delete []canvas ;
}
void CFaceBitmap::ToFreeImage(FIBITMAP* image,int x,int y,RGBQUAD* fg)
{
bool newfg=false;
static int l = 2;
RGBQUAD bg ;
if(!fg)
{
fg = new RGBQUAD();
memset(fg,0,sizeof(RGBQUAD));
newfg = true;
}
int w = GetWidth();
int h = GetHeight();
for ( int i=0;i<h;i+=l )
{
l+=2;l%=3;
for ( int j=0;j<w;j+=2 )
{
if((pBmp->buffer[i*w+j]!=0||pBmp->buffer[i*w+j]!=0|| pBmp->buffer[i*w+j]!=0))
{
FreeImage_SetPixelColor(image,j+x,h-i+y,fg);
}
else
{
FreeImage_GetPixelColor(image,j+x,h-i+y,&bg);
FreeImage_SetPixelColor(image,j+x,h-i+y,&bg);
}
}
}
if(newfg)
delete fg;
}
void painter::rasterize_line(FIBITMAP* bitmap,
boost::geometry::model::d2::point_xy<double> p1, boost::geometry::model::d2::point_xy<double> p2)
{
int sx(round(p1.x())), sy(round(p1.y())), ex(round(p2.x())), ey(round(p2.y()));
int dx(ex - sx), dy(ey - sy);
FreeImage_SetPixelColor(bitmap, sx, sy, border_color);
if (abs(dx) >= abs(dy))
{
if (dx == 0) return;
int x = sx, xinc = dx > 0 ? 1 : -1;
double y = sy, yinc = static_cast<double>(dy) / dx * xinc;
while (x != ex)
{
x += xinc;
y += yinc;
FreeImage_SetPixelColor(bitmap, x, round(y), border_color);
}
}
else
{
if (dy == 0) return;
int y = sy, yinc = dy > 0 ? 1 : -1;
double x = sx, xinc = static_cast<double>(dx) / dy * yinc;
while (y != ey)
{
x += xinc;
y += yinc;
FreeImage_SetPixelColor(bitmap, round(x), y, border_color);
}
}
}
void Film :: writeImage(){
if(AA_CONTROL){
for(int k = 0; k < AA; k++){
for(int j = 0; j < sizeY; j++){
for(int i = 0; i < sizeX; i++){
if(i == 0 && j == 0){
aa[i + j * sizeY] = (matrix[i + 1 + j * sizeY] + matrix[i + 1 + (j + 1) * sizeY] + matrix[i + (j + 1) * sizeY]) / 3.0;
continue;
} else if((i + 1) == sizeX && (j + 1 == sizeY)) {
aa[i + j * sizeY] = (matrix[i - 1 + j * sizeY] + matrix[i - 1 + (j - 1) * sizeY] + matrix[i + (j - 1) * sizeY]) / 3.0;
continue;
} else if((i + 1) == sizeX) {
aa[i + j * sizeY] = (matrix[i - 1 + j * sizeY] + matrix[i - 1 + (j + 1) * sizeY] + matrix[i + (j + 1) * sizeY] + matrix[i + (j - 1) * sizeY] + matrix[i - 1 + (j - 1) * sizeY]) / 5.0;
continue;
} else if((j + 1) == sizeY) {
aa[i + j * sizeY] = (matrix[i - 1 + j * sizeY] + matrix[i - 1 + (j - 1) * sizeY] + matrix[i + (j - 1) * sizeY] + matrix[i + 1 + j * sizeY] + matrix[i + 1 + (j - 1) * sizeY]) / 5.0;
continue;
} else if(i == 0){
aa[i + j * sizeY] = (matrix[i + 1 + j * sizeY] + matrix[i + 1 + (j + 1) * sizeY] + matrix[i + (j + 1) * sizeY] + matrix[i + (j - 1) * sizeY] + matrix[i + 1 + (j - 1) * sizeY]) / 5.0;
continue;
} else if(j == 0){
aa[i + j * sizeY] = (matrix[i - 1 + j * sizeY] + matrix[i - 1 + (j + 1) * sizeY] + matrix[i + (j + 1) * sizeY] + matrix[i + 1 + j * sizeY] + matrix[i + 1 + (j + 1) * sizeY]) / 5.0;
continue;
} else {
aa[i + j * sizeY] = (matrix[i - 1 + (j + 1) * sizeY] + matrix[i + (j + 1) * sizeY] + matrix[i + 1 + (j + 1) * sizeY] + matrix[i + j * sizeY] + matrix[i + 1 + (j - 1) * sizeY] + matrix[i + (j - 1) * sizeY] + matrix[i - 1 + (j - 1) * sizeY] + matrix[i - 1 + j * sizeY]) / 8.0;
continue;
}
}
}
free(matrix);
matrix = aa;
aa = (vec3 *) malloc(sizeof(vec3) * sizeX * sizeY);
}
}
if (EXPOSURE_CONTROL){
#pragma omp parallel for default(none) shared(color, matrix, sizeY) private(i, j) nowait
for(int j = 0; j < sizeY; j++){
for(int i = 0; i < sizeX; i++){
color.rgbRed = (1.0f - expf(matrix[i + j * sizeY][0] * EXPOSURE)) * 255.;
color.rgbGreen = (1.0f - expf(matrix[i + j * sizeY][1] * EXPOSURE)) * 255.;
color.rgbBlue = (1.0f - expf(matrix[i + j * sizeY][2] * EXPOSURE)) * 255.;
FreeImage_SetPixelColor(bitmap, i , j , &color);
}
}
} else{
for(int j = 0; j < sizeY; j++){
for(int i = 0; i < sizeX; i++){
color.rgbRed = min((float)matrix[i + j * sizeY][0],1.0f) * 255.;
color.rgbGreen = min((float)matrix[i + j * sizeY][1],1.0f) * 255.;
color.rgbBlue = min((float)matrix[i + j * sizeY][2],1.0f) * 255.;
FreeImage_SetPixelColor(bitmap, i , j , &color);
}
}
}
free(aa);
free(matrix);
}
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 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();
}
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;
}
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);
}
}
static bool mergeBitBltToRGBA(FIBITMAP *image, const std::string &pathToMask)
{
if(!image)
return false;
if(!Files::fileExists(pathToMask))
return false; //Nothing to do
FIBITMAP *mask = loadImage(pathToMask);
if(!mask)
return false;//Nothing to do
unsigned int img_w = FreeImage_GetWidth(image);
unsigned int img_h = FreeImage_GetHeight(image);
unsigned int mask_w = FreeImage_GetWidth(mask);
unsigned int mask_h = FreeImage_GetHeight(mask);
RGBQUAD Fpix;
RGBQUAD Bpix;
RGBQUAD Npix = {0x0, 0x0, 0x0, 0xFF};
for(unsigned int y = 0; (y < img_h) && (y < mask_h); y++)
{
for(unsigned int x = 0; (x < img_w) && (x < mask_w); x++)
{
FreeImage_GetPixelColor(image, x, y, &Fpix);
FreeImage_GetPixelColor(mask, x, y, &Bpix);
Npix.rgbRed = ((0x7F & Bpix.rgbRed) | Fpix.rgbRed);
Npix.rgbGreen = ((0x7F & Bpix.rgbGreen) | Fpix.rgbGreen);
Npix.rgbBlue = ((0x7F & Bpix.rgbBlue) | Fpix.rgbBlue);
int newAlpha = 255 -
((int(Bpix.rgbRed) +
int(Bpix.rgbGreen) +
int(Bpix.rgbBlue)) / 3);
if((Bpix.rgbRed > 240u) //is almost White
&& (Bpix.rgbGreen > 240u)
&& (Bpix.rgbBlue > 240u))
newAlpha = 0;
newAlpha = newAlpha + ((int(Fpix.rgbRed) +
int(Fpix.rgbGreen) +
int(Fpix.rgbBlue)) / 3);
if(newAlpha > 255)
newAlpha = 255;
Npix.rgbReserved = newAlpha;
FreeImage_SetPixelColor(image, x, y, &Npix);
}
}
FreeImage_Unload(mask);
return true;
}
int main(int argc, char *argv[])
{
if (argc != 3)
{
printf("Usage : cworld2img input_filename.bin output_filename.png\n\n");
return 0;
}
FreeImage_Initialise();
FIBITMAP *bitmap = FreeImage_Allocate(WORLD_WIDTH, WORLD_HEIGHT, 32);
if(!bitmap)
{
printf("Error while allocating image. Aborting");
return -1;
}
FILE *fd = fopen(argv[1], "rb");
fread(c_world.solids, sizeof(block), WORLD_HEIGHT * WORLD_WIDTH, fd);
fclose(fd);
for(int i = 0; i < WORLD_HEIGHT; i++)
{
for(int j = 0; j < WORLD_WIDTH; j++)
{
switch(c_world.solids[WORLD_WIDTH * i + j])
{
case BLCK_AIR:
FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_air);break;
case BLCK_DIRT:
FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_dirt);break;
default:
FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_unknown);break;
}
}
}
if(!FreeImage_Save(FIF_PNG, bitmap, argv[2], 0))
{
printf("Error while saving image. Aborting");
return -1;
}
FreeImage_DeInitialise();
return 0;
}
static void splitRGBAtoBitBlt(FIBITMAP * &image, FIBITMAP *&mask)
{
unsigned int img_w = FreeImage_GetWidth(image);
unsigned int img_h = FreeImage_GetHeight(image);
mask = FreeImage_AllocateT(FIT_BITMAP,
img_w, img_h,
FreeImage_GetBPP(image),
FreeImage_GetRedMask(image),
FreeImage_GetGreenMask(image),
FreeImage_GetBlueMask(image));
RGBQUAD Fpix;
RGBQUAD Npix = {0x0, 0x0, 0x0, 0xFF};
for(unsigned int y = 0; (y < img_h); y++)
{
for(unsigned int x = 0; (x < img_w); x++)
{
FreeImage_GetPixelColor(image, x, y, &Fpix);
uint8_t grey = (255 - Fpix.rgbReserved);
Npix.rgbRed = grey;
Npix.rgbGreen= grey;
Npix.rgbBlue = grey;
Npix.rgbReserved = 255;
Fpix.rgbRed = subtractAlpha(Fpix.rgbRed, grey);
Fpix.rgbGreen= subtractAlpha(Fpix.rgbGreen, grey);
Fpix.rgbBlue = subtractAlpha(Fpix.rgbBlue, grey);
Fpix.rgbReserved = 255;
FreeImage_SetPixelColor(image, x, y, &Fpix);
FreeImage_SetPixelColor(mask, x, y, &Npix);
}
}
}
void Generate_thread(FIBITMAP* bitmap, Camera camera,int init_num, int thread_num) {
for (int i = init_num; i < Width; i += thread_num) {
cout << i << endl;
for (int j = 0; j < Height; j++) {
RGBQUAD color;
vec3 mycolor;
Ray ray = camera.GenerateRay(vec2(i, j));
mycolor = Trace(ray);
color.rgbRed = mycolor.x * 255;
color.rgbGreen = mycolor.y * 255;
color.rgbBlue = mycolor.z * 255;
FreeImage_SetPixelColor(bitmap, i, j, &color);
}
}
}
void saveImage(const char* _fileName, unsigned char* _image, int _width, int _height)
{
FIBITMAP* resultImage = FreeImage_Allocate(_width, _height, 24);
for(int y = 1; y <= _height; ++y)
for(int x = 0; x < _width; ++x)
{
int color = *_image;
color = (color << 8) | (color << 16) | (color) | (color << 24);
FreeImage_SetPixelColor(resultImage, x, _height - y, (RGBQUAD*)(&color));
++_image;
}
FreeImage_Save(FIF_BMP, resultImage, _fileName);
}
void ThinLens::render_scene(World& w) {
RGBColor L;
Ray ray;
ViewPlane vp(w.vp);
FreeImage_Initialise();
FIBITMAP* bitmap = FreeImage_Allocate(vp.hres, vp.vres, 24);
RGBQUAD color;
int depth = 0;
Point2D sp;
Point2D pp;
Point2D dp;
Point2D lp;
vp.s /= zoom;
for(int r = 0; r < vp.vres; r++)
for(int c = 0 ; c < vp.hres; c++) {
L = black;
for(int n = 0; n < vp.num_samples; n++) {
sp = vp.sampler_ptr -> sample_unit_square();
pp.x = vp.s * (c - vp.hres / 2.0 + sp.x);
pp.y = vp.s * (r - vp.vres / 2.0 + sp.y);
dp = sampler_ptr -> sample_unit_disk();
lp = dp * lens_radius;
ray.o = eye + lp.x * u + lp.y * v;
ray.d = ray_direction(pp, lp);
L += w.tracer_ptr -> trace_ray(ray);
}
L /= vp.num_samples;
L *= exposure_time;
w.display_pixel(r, c, L);
color.rgbRed = (int)(L.r*255);
color.rgbGreen = (int)(L.g*255);
color.rgbBlue = (int)(L.b*255);
FreeImage_SetPixelColor(bitmap, c, r, &color);
}
if (FreeImage_Save(FIF_PNG, bitmap, "test.png", 0))
std::cout << "Image Successfully Saved!" << std::endl;
FreeImage_DeInitialise();
}
void painter::paint(string file, lattice::phenotypes::phenotype const& phenotype, string path)
{
FIBITMAP *bitmap = FreeImage_Allocate(
phenotype.get_width() * SCALEFACTOR, phenotype.get_height() * SCALEFACTOR, BPP);
RGBQUAD color;
auto& cells = phenotype.expose_cells();
vector<polygon> sc_polys;
for (auto& cell : cells)
{
lattice::rgb cellColor;
polygon cellPoly = cell->get_geometry(), scaled;
boost::geometry::strategy::transform::scale_transformer<double, 2, 2> scale(static_cast<double>(SCALEFACTOR));
boost::geometry::transform(cellPoly, scaled, scale);
sc_polys.push_back(scaled);
boost::geometry::model::box<point> box;
boost::geometry::envelope(scaled, box);
for (unsigned int y = static_cast<unsigned int>(box.min_corner().get<1>());
y <= box.max_corner().get<1>(); ++y)
{
for (unsigned int x = static_cast<unsigned int>(box.min_corner().get<0>());
x <= box.max_corner().get<0>(); ++x)
{
boost::geometry::model::d2::point_xy<double> p(x, y);
if (!boost::geometry::covered_by(p, scaled)) continue;
cellColor = cell->get_state().color;
color.rgbRed = cellColor.r;
color.rgbGreen = cellColor.g;
color.rgbBlue = cellColor.b;
FreeImage_SetPixelColor(bitmap, x, y, &color);
}
}
}
for (auto& poly : sc_polys) rasterize_polygon_border(bitmap, poly);
string fullPath = path + "/";
boost::filesystem::create_directory(fullPath);
FIBITMAP *scaled = FreeImage_Rescale(bitmap, DESIRED_WIDTH, DESIRED_HEIGHT, FILTER_BOX);
FreeImage_Save(FIF_PNG, scaled, (fullPath + file).c_str(), 0);
FreeImage_Unload(bitmap);
FreeImage_Unload(scaled);
}
void PImage::save(const char * out) {
FIBITMAP *bitmap = FreeImage_Allocate(width, height, 24);
RGBQUAD c;
if (!bitmap) exit(1);
for(int y=0; y<height; y++) {
for(int x=0; x<width; x++) {
c.rgbRed = texturebuffer[(((y*width)+x)*4)+0];
c.rgbGreen = texturebuffer[(((y*width)+x)*4)+1];
c.rgbBlue = texturebuffer[(((y*width)+x)*4)+2];
FreeImage_SetPixelColor(bitmap, x, y, &c);
}
}
FreeImage_Save(FIF_PNG, bitmap, out, 0);
FreeImage_Unload(bitmap);
}
void Fisheye::render_scene(World& w) {
RGBColor L;
ViewPlane vp(w.vp);
FreeImage_Initialise();
FIBITMAP* bitmap = FreeImage_Allocate(vp.hres, vp.vres, 24);
RGBQUAD color;
int hres = vp.hres;
int vres = vp.vres;
float s = vp.s;
Ray ray;
int depth = 0;
Point2D sp;
Point2D pp;
float r_squared;
ray.o = eye;
for(int r = 0; r < vres; r++)
for(int c = 0; c < hres; c++) {
L = black;
for(int j = 0; j < vp.num_samples; j++) {
sp = vp.sampler_ptr -> sample_unit_square();
pp.x = s * (c - hres / 2.0 + sp.x);
pp.y = s * (r - vres / 2.0 + sp.y);
ray.d = ray_direction(pp, hres, vres, s, r_squared);
if(r_squared <= 1.0)
L += w.tracer_ptr -> trace_ray(ray);
}
L /= vp.num_samples;
L *= exposure_time;
w.display_pixel(r, c, L);
color.rgbRed = (int)(L.r*255);
color.rgbGreen = (int)(L.g*255);
color.rgbBlue = (int)(L.b*255);
FreeImage_SetPixelColor(bitmap, c, r, &color);
}
if (FreeImage_Save(FIF_PNG, bitmap, "test.png", 0))
std::cout << "Image Successfully Saved!" << std::endl;
FreeImage_DeInitialise();
}
//write_img
void write_img(char *name, pixel *data, int width, int height) {
FIBITMAP *image;
RGBQUAD aPixel;
int i, j;
image = FreeImage_Allocate(width, height, 24, 0, 0, 0);
if (!image) {
perror("FreeImage_Allocate");
return;
}
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
aPixel.rgbRed = data[i*width + j].r;
aPixel.rgbGreen = data[i*width + j].g;
aPixel.rgbBlue = data[i*width + j].b;
FreeImage_SetPixelColor(image, j, i, &aPixel);
}
}
if (!FreeImage_Save(FIF_TIFF, image, name, 0)) {
perror("FreeImage_Save");
}
FreeImage_Unload(image);
}//write_img
void *process_thread(void *data)
{
struct thread_data *args;
args = (struct thread_data*) data;
std::queue<std::string> *input = args -> input;
std::mutex *lock = args -> lock;
double brightness = args -> brightness;
double gamma = args -> gamma;
std::string infile;
std::string outfile;
bool exists;
while (true)
{
exists = false;
while (!(lock -> try_lock()));
if (input -> empty())
{
lock -> unlock();
break;
}
infile = input -> front();
input -> pop();
lock -> unlock();
gen_edit_filename(infile, outfile);
DIR *editdir = opendir("img/edit");
struct dirent *file;
while ((file = readdir(editdir)) != NULL)
{
if (strcmp(file -> d_name, outfile.c_str()) == 0)
{
exists = true;
break;
}
}
closedir(editdir);
infile = "img/" + infile;
outfile = "img/edit/" + outfile;
if (exists) { continue; }
else
{
while (!(lock -> try_lock()));
std::cout << "Processing " << infile << std::endl;
lock -> unlock();
}
FIBITMAP *input = FreeImage_Load(FIF_PNG, infile.c_str());
if (input == NULL)
{
while (!(lock -> try_lock()));
std::cerr << "Failed to load " << infile << std::endl;
lock -> unlock();
exit(1);
}
if (!FreeImage_Save(FIF_PNG, input, outfile.c_str()))
{
FreeImage_Unload(input);
while (!(lock -> try_lock()));
std::cerr << "Failed to save " << outfile << std::endl;
lock -> unlock();
exit(1);
}
FreeImage_Unload(input);
FIBITMAP *output = FreeImage_Load(FIF_PNG, outfile.c_str());
if (output == NULL)
{
while (!(lock -> try_lock()));
std::cerr << "Failed to load " << outfile << std::endl;
lock -> unlock();
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);
while (!(lock -> try_lock()));
std::cerr << "Failed to save " << outfile << std::endl;
lock -> unlock();
exit(1);
}
FreeImage_Unload(output);
while (!(lock -> try_lock()));
std::cout << "Saved " << outfile << std::endl;
lock -> unlock();
}
pthread_exit(NULL);
}
BOOL fipImage::setPixelColor(unsigned x, unsigned y, RGBQUAD *value) {
_bHasChanged = TRUE;
return FreeImage_SetPixelColor(_dib, x, y, value);
}
void TileManager::ProcessTileMap(std::string a_sFileName)
{
m_sCurrentLevel = a_sFileName;
int rows = m_pBaseSprite[a_sFileName]->GetHeight() / TILE_HEIGHT;
int columns = m_pBaseSprite[a_sFileName]->GetWidth() / TILE_WIDTH;
int idCounter = 0;
int id = 0;
int counter = 0;
for(int row = 0; row < rows; row++)
{
for(int col = 0; col < columns; col++)
{
Tmpl8::Surface* surface = new Tmpl8::Surface(TILE_WIDTH, TILE_HEIGHT);
m_pBaseSprite[a_sFileName]->CopyPartTo(surface, 0, 0, col * TILE_WIDTH, row * TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
if(row == 0 && col == 0)
{
TileNode* tileNode = new TileNode(row, col, 0);
m_pTiles[a_sFileName].push_back(tileNode);
m_pTileSurfaces[a_sFileName].push_back(new TileSurface(idCounter,surface));
tileNode->SetSurface(tileNode->m_iTileId);
counter++;
idCounter++;
continue;
}
bool isUnique = true;
for(std::vector<TileSurface*>::iterator iter = m_pTileSurfaces[a_sFileName].begin(); iter != m_pTileSurfaces[a_sFileName].end();)
{
if(!(*iter)->CompareSurfaces(surface))
{
isUnique = false;
id = (*iter)->m_iTileId;
iter = m_pTileSurfaces[a_sFileName].end();
}
else
{
iter++;
}
}
if(isUnique)
{
m_pTileSurfaces[a_sFileName].push_back(new TileSurface(idCounter,surface));
id = idCounter;
idCounter++;
}
else
{
delete surface;
}
TileNode* tileNode = new TileNode(row, col, id);
m_pTiles[a_sFileName].push_back(tileNode);
tileNode->SetSurface(tileNode->m_iTileId);
counter++;
}
}
FIBITMAP* bitmap = FreeImage_Allocate(512, 1024, 24);
int tilesInRow = 512 / TILE_WIDTH;
int rowCounter = 0;
int colCounter = 0;
for(std::vector<TileSurface*>::iterator iter = m_pTileSurfaces[a_sFileName].begin(); iter != m_pTileSurfaces[a_sFileName].end(); iter++)
{
Tmpl8::Pixel* buffer = (*iter)->m_pTileSurface->GetBuffer();
int pitch = (*iter)->m_pTileSurface->GetPitch();
for(int x = 0; x < TILE_WIDTH; x++)
{
for(int y = 0; y < TILE_HEIGHT; y++)
{
RGBQUAD color;
color.rgbRed = (buffer[x + y*pitch] & 0xFF0000) >> 16;
color.rgbGreen = (buffer[x + y*pitch] & 0x00FF00) >> 8;
color.rgbBlue = buffer[x + y*pitch] & 0x0000FF;
FreeImage_SetPixelColor(bitmap, colCounter*TILE_WIDTH + x, 1023 - rowCounter*TILE_HEIGHT - y, &color);
}
}
colCounter++;
if(colCounter >= tilesInRow)
{
colCounter = 0;
rowCounter++;
}
}
FreeImage_Save(FIF_PNG, bitmap, std::string("assets/tilesets/"+a_sFileName+"_tilemap.png").c_str(), 0);
std::string tileMap;
std::stringstream ss;
counter = 0;
for(int row = 0; row < rows; row++)
{
for(int col = 0; col < columns; col++)
{
TileNode* currentNode = m_pTiles[a_sFileName][counter];
counter++;
ss.str("");
ss << currentNode->m_iTileId;
tileMap += ss.str();
if(col+1 != columns)
tileMap += ",";
}
if(row+1 != rows)
tileMap += "\n";
}
std::ofstream tilemapFile;
tilemapFile.open (std::string("assets/tilesets/"+a_sFileName+".dat").c_str());
tilemapFile << tileMap;
tilemapFile.close();
std::ofstream metaFile;
metaFile.open (std::string("assets/tilesets/"+a_sFileName+"_metadata.dat").c_str());
ss.str("");
ss << m_pTileSurfaces[a_sFileName].size() << "," << TILE_WIDTH << "," << TILE_HEIGHT << "," << m_pBaseSprite[a_sFileName]->GetWidth() << "," << m_pBaseSprite[a_sFileName]->GetHeight();
metaFile << ss.str();
metaFile.close();
for(std::vector<TileSurface*>::iterator iter = m_pTileSurfaces[a_sFileName].begin(); iter != m_pTileSurfaces[a_sFileName].end(); iter++)
{
delete *iter;
}
m_pTileSurfaces[a_sFileName].clear();
for(std::vector<TileNode*>::iterator iter = m_pTiles[a_sFileName].begin(); iter != m_pTiles[a_sFileName].end(); iter++)
{
delete *iter;
}
m_pTiles[a_sFileName].clear();
delete m_pBaseSprite[a_sFileName];
}
/**
* This method sets the color on the given position.
*
* @param ulX the horizontal (x) position, on which to set the color
* @param ulY the vertical (y) position, on which to set the color
* @param colorValue a pointer to the color value field to set
* @return true if pixel color was set, else false
*/
bool fipImage::setPixelColor( const unsigned long ulX, const unsigned long ulY,
RGBQUAD * colorValue ){
return FreeImage_SetPixelColor( pImageData, ulX, ulY, colorValue );
}
void Image::setPixel(RGBQUAD &rgb, int x, int y) const {
FreeImage_SetPixelColor(m_fiImage, x, y, &rgb);
}
void CFontTexCreaterDlg::OnBnClickedButton1()
{
int texW = 2048 ;
int texH = 2048 ;
FILE* pF = fopen( "FontBuf" , "rb" ) ;
fseek( pF , 0 , SEEK_END ) ;
DWORD fileSz = ftell( pF ) ;
char *bf = new char[ fileSz ] ;
fseek( pF , 0 , SEEK_SET ) ;
fread( bf , fileSz , 1 , pF ) ;
if( fileSz == 1024 * 1024 )
{
texW = 1024 ;
texH = 1024 ;
}
else if( fileSz == 2048 * 1024 )
{
texW = 1024 ;
texH = 2048 ;
}
else if( fileSz == 2048 * 2048 )
{
texW = 2048 ;
texH = 2048 ;
}
else
{
::MessageBoxA( NULL , "FontBuf's size is wrong." , "" , MB_OK ) ;
}
fclose( pF ) ;
//
{
FreeImage_Initialise() ;
FIBITMAP* bm = FreeImage_Allocate( texW , texH , 24 ) ;
RGBQUAD clr ;
for( int y = 0 ; y < texH ; y ++ )
{
for( int x = 0 ; x < texW ; x ++ )
{
char val = bf[ y * texW + x ] ;
clr.rgbBlue = val ;
clr.rgbGreen = val ;
clr.rgbRed = val ;
clr.rgbReserved = 255 ;
FreeImage_SetPixelColor( bm , x , texH - 1 - y , &clr ) ;
}
}
FreeImage_Save( FIF_BMP , bm , "FontBuf.bmp" ) ;
FreeImage_Unload( bm ) ;
FreeImage_DeInitialise() ;
}
}
void Image_Output()
{
/*
FreeImage_Initialise();
FIBITMAP *m_image = FreeImage_Allocate( M * W - 1, M * H - 1, 24 );
struct tagRGBQUAD rgbquad;
for ( int i = 0; i < M * H - 1; ++i )
{
for ( int j = 0; j < M * W - 1; ++j )
{
rgbquad.rgbRed = o_image[i][j].r;
rgbquad.rgbGreen = o_image[i][j].g;
rgbquad.rgbBlue = o_image[i][j].b;
FreeImage_SetPixelColor( m_image, j, i, &rgbquad );
}
}
FreeImage_Save( FIF_BMP, m_image, o_file, BMP_DEFAULT );
FreeImage_DeInitialise();
*/
FreeImage_Initialise();
FIBITMAP *m_image = FreeImage_Allocate( M * W, M * H, 24 );
struct tagRGBQUAD rgbquad;
for ( int i = 0; i < M * H; ++i )
{
for ( int j = 0; j < M * W; ++j )
{
if ( i == ( M * H - 1 ) || j == ( M * W - 1 ) )
{
int u = 0, v = 0;
if ( i == ( M * H - 1 ) )
{
u = -1;
}
if ( j == ( M * W - 1 ) )
{
v = -1;
}
rgbquad.rgbRed = o_image[i+u][j+v].r;
rgbquad.rgbGreen = o_image[i+u][j+v].g;
rgbquad.rgbBlue = o_image[i+u][j+v].b;
FreeImage_SetPixelColor( m_image, j, i, &rgbquad );
}
else
{
rgbquad.rgbRed = o_image[i][j].r;
rgbquad.rgbGreen = o_image[i][j].g;
rgbquad.rgbBlue = o_image[i][j].b;
FreeImage_SetPixelColor( m_image, j, i, &rgbquad );
}
}
}
FreeImage_Save( FIF_BMP, m_image, o_file, BMP_DEFAULT );
FreeImage_DeInitialise();
}
bool IPLFileIO::saveFile(const std::string path, IPLImage* image, int format, int flags, IPLImage* result, bool preview)
{
int width = image->width();
int height = image->height();
FIBITMAP *dib = FreeImage_Allocate(width, height, 24);
if(image->type() == IPLData::IMAGE_COLOR)
{
for(int y = 0; y < height; y++)
{
for(int x = 0; x < width; x++)
{
RGBQUAD rgb;
rgb.rgbRed = static_cast<BYTE>(image->plane(0)->p(x, y) * FACTOR_TO_UCHAR); // R
rgb.rgbGreen = static_cast<BYTE>(image->plane(1)->p(x, y) * FACTOR_TO_UCHAR); // G
rgb.rgbBlue = static_cast<BYTE>(image->plane(2)->p(x, y) * FACTOR_TO_UCHAR); // B
FreeImage_SetPixelColor(dib, x, y, &rgb);
}
}
}
else
{
for(int y = 0; y < height; y++)
{
for(int x = 0; x < width; x++)
{
unsigned char value = image->plane(0)->p(x, y) * FACTOR_TO_UCHAR;
RGBQUAD rgb;
rgb.rgbRed = value; // R
rgb.rgbGreen = value; // G
rgb.rgbBlue = value; // B
FreeImage_SetPixelColor(dib, x, y, &rgb);
}
}
}
// all files need to be flipped
FreeImage_FlipVertical(dib);
bool success = false;
if(preview)
{
// only save to memory for preview
FIMEMORY* hmem = NULL;
// open and allocate a memory stream
hmem = FreeImage_OpenMemory();
success = FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)format, dib, hmem, flags) != 0;
// write to result
if(result)
{
loadMemory((void*)hmem, result);
}
//FreeImage_CloseMemory(hmem);
}
else
{
// actually save file
success = FreeImage_Save((FREE_IMAGE_FORMAT)format, dib, path.c_str(), flags) != 0;
// write to result
if(result)
{
std::string information;
loadFile(path, result, information);
}
}
// free temporary memory
FreeImage_Unload(dib);
return success;
}
bool Image::load (const char* fname)
{
release () ;
// createTestData () ;
// return true ;
char buf[256] ;
sprintf_s (buf, sizeof (buf), "image\\%s", fname) ;
// fname = "image\\avatar000.png" ;
FILE* pFile = NULL ;
fopen_s (&pFile, buf, "rb") ;
if (pFile == NULL)
return false ;
FreeImageIO io;
io.read_proc = myReadProc;
io.write_proc = myWriteProc;
io.seek_proc = mySeekProc;
io.tell_proc = myTellProc;
// find the buffer format
FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)pFile, 0);
if(fif == FIF_UNKNOWN)
{
/* Close the file */
fclose(pFile);
return false ;
}
// load from the file handle
FIBITMAP *dib = FreeImage_LoadFromHandle(fif, &io, (fi_handle)pFile, 0);
BYTE* pPixelData = FreeImage_GetBits(dib) ;
int width, height,pitch ;
width = FreeImage_GetWidth(dib);
height = FreeImage_GetHeight(dib);
pitch = FreeImage_GetPitch(dib);
int bpp = FreeImage_GetBPP(dib) ;
assert (bpp == 32) ;
FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib) ;
assert (image_type == FIT_BITMAP) ;
// /*
//轉換rgba(因為rgba,的順序不同)
RGBQUAD rgba ;
BYTE* pBit = pPixelData ;
for (int i = 0 ; i<height; i++)
{
BYTE* pPixel = pBit ;
for (int m = 0; m<width; m++)
{
if (FreeImage_GetPixelColor(dib, m, i, &rgba))
{
BYTE tmp = rgba.rgbBlue ;
rgba.rgbBlue = rgba.rgbRed ;
rgba.rgbRed = tmp ;
FreeImage_SetPixelColor (dib, m, i, &rgba) ;
}
}
pBit += pitch ;
}
// */
//---------------------------------------------------
//把pixel copy給
//最大記憶體
if (pPixelData != NULL)
{
assert (textureID == NO_TEXTURE_ID) ;
if (textureID == NO_TEXTURE_ID)
{
//空的要先建立
// Allocates one texture handle
glGenTextures(1, &textureID);
}
assert (textureID != NO_TEXTURE_ID) ;
// Binds this texture handle so we can load the data into it
glBindTexture(GL_TEXTURE_2D, textureID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pPixelData);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
// free the loaded FIBITMAP
FreeImage_Unload(dib);
}
return true ;
}
int main(int argc, char** argv)
{
if(argc < 2)
{
printf("Error! No Font Specified!\n");
return 1;
}
std::string filename(argv[1]);
const size_t last_slash_idx = filename.find_last_of("\\/");
if (std::string::npos != last_slash_idx)
{
filename.erase(0, last_slash_idx + 1);
}
// Remove extension if present.
const size_t period_idx = filename.rfind('.');
if (std::string::npos != period_idx)
{
filename.erase(period_idx);
}
FIBITMAP* bitmap = FreeImage_Allocate(4096, 4096, 32);
FreeImage_SetTransparent(bitmap, true);
FT_Library library;
FT_Init_FreeType(&library);
FT_Face face;
FT_New_Face(library, argv[1], 0, &face);
rapidjson::StringBuffer s;
rapidjson::Writer<rapidjson::StringBuffer> writer(s);
writer.StartObject();
writer.String("glyphs");
writer.StartArray();
int tileSize = 64;
int tileCount = 64;
FT_Set_Pixel_Sizes(face, 0, tileSize);
for (int c = 32, id = 0; c < 4096; ++c, ++id)
{
FT_Load_Char(face, c, FT_LOAD_RENDER);
FT_Bitmap bmp = face->glyph->bitmap;
FT_Glyph_Metrics metrics = face->glyph->metrics;
int i = 0, j = 0;
for (j = 0; j < bmp.rows; ++j)
{
for (i = 0; i < bmp.width; ++i)
{
RGBQUAD value = {bmp.buffer[j * bmp.width + i],
bmp.buffer[j * bmp.width + i],
bmp.buffer[j * bmp.width + i],
bmp.buffer[j * bmp.width + i]};
FreeImage_SetPixelColor(
bitmap, (id % tileCount) * tileSize + i,
(id / tileCount) * tileSize + bmp.rows - j, &value);
}
}
double x = (id % tileCount) * tileSize;
double y = (id / tileCount) * tileSize;
writer.StartObject();
{
writer.String("id");
writer.Uint(c);
writer.String("char");
writer.String((const char*)&c);
writer.String("metrics");
writer.StartObject();
{
writer.String("width");
writer.Int(metrics.width / 64);
writer.String("height");
writer.Int(metrics.height / 64);
writer.String("horiBearingX");
writer.Int(metrics.horiBearingX / 64);
writer.String("horiBearingY");
writer.Int(metrics.horiBearingY / 64);
writer.String("horiAdvance");
writer.Int(metrics.horiAdvance / 64);
writer.String("vertBearingX");
writer.Int(metrics.vertBearingX / 64);
writer.String("vertBearingY");
writer.Int(metrics.vertBearingY / 64);
writer.String("vertAdvance");
writer.Int(metrics.vertAdvance / 64);
}
writer.EndObject();
writer.String("uv");
writer.StartArray();
writer.StartArray();
writer.Double(x / 4096.0);
writer.Double((y - metrics.height / 64) / 4096.0);
writer.EndArray();
writer.StartArray();
writer.Double(x / 4096.0);
writer.Double(y / 4096.0);
writer.EndArray();
writer.StartArray();
writer.Double((x + metrics.width / 64) / 4096.0);
writer.Double(y / 4096.0);
writer.EndArray();
writer.StartArray();
writer.Double((x + metrics.width / 64) / 4096.0);
writer.Double((y - metrics.height / 64) / 4096.0);
writer.EndArray();
writer.EndArray();
}
writer.EndObject();
}
writer.EndArray();
writer.EndObject();
FILE* fp = fopen((filename + ".json").c_str(), "w");
fputs(s.GetString(), fp);
fclose(fp);
if (FreeImage_Save(FIF_PNG, bitmap, (filename + ".png").c_str(), BMP_DEFAULT))
{
printf("Saved file to %s\n", (filename + ".png").c_str());
}
FreeImage_Unload(bitmap);
return 0;
}