/* Wait until file has a stable size --------------------------------------- */
void FileName::waitUntilStableSize(size_t time_step)
{
size_t idx;
FileName basicName;
decompose(idx, basicName);
if (!exists())
return;
Stat info1, info2;
if (stat(basicName.c_str(), &info1))
REPORT_ERROR(ERR_UNCLASSIFIED,
(String)"FileName::waitUntilStableSize: Cannot get size of file " + *this);
off_t size1 = info1.st_size;
do
{
usleep(time_step);
if (stat(basicName.c_str(), &info2))
REPORT_ERROR(ERR_UNCLASSIFIED,
(String)"FileName::waitUntilStableSize: Cannot get size of file " + *this);
off_t size2 = info2.st_size;
if (size1 == size2)
break;
size1 = size2;
}
while (true);
return;
}
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);
}
}
bool setWorkingDirectory(const FileName &path)
{
int result = -1;
#ifdef _WIN32
result = _chdir(path.c_str());
#else
result = chdir(path.c_str());
#endif
return result >= 0;
}
// Compute fitness =========================================================
double ObjFunc_nma_alignment::eval(Vector X, int *nerror) {
int dim = global_nma_prog->numberOfModes;
for (int i = 0; i < dim; i++) {
global_nma_prog->trial(i) = X[i];
}
int pyramidLevelDisc = 1;
int pyramidLevelCont = (global_nma_prog->currentStage == 1) ? 1 : 0;
FileName fnRandom = global_nma_prog->createDeformedPDB(pyramidLevelCont);
const char * randStr = fnRandom.c_str();
if (global_nma_prog->currentStage == 1) {
global_nma_prog->performCompleteSearch(fnRandom, pyramidLevelDisc);
} else {
double rot, tilt, psi, xshift, yshift;
MetaData DF;
rot = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 5);
tilt = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 4);
psi = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 3);
xshift = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 2);
yshift = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 1);
size_t objId = DF.addObject();
FileName fnDown = formatString("%s_downimg.xmp", randStr);
DF.setValue(MDL_IMAGE, fnDown, objId);
DF.setValue(MDL_ENABLED, 1, objId);
DF.setValue(MDL_ANGLE_ROT, rot, objId);
DF.setValue(MDL_ANGLE_TILT, tilt, objId);
DF.setValue(MDL_ANGLE_PSI, psi, objId);
DF.setValue(MDL_SHIFT_X, xshift, objId);
DF.setValue(MDL_SHIFT_Y, yshift, objId);
DF.write(formatString("%s_angledisc.xmd", randStr));
copyImage(global_nma_prog->currentImgName.c_str(), fnDown.c_str());
}
double fitness = global_nma_prog->performContinuousAssignment(fnRandom,
pyramidLevelCont);
runSystem("rm", formatString("-rf %s* &", randStr));
global_nma_prog->updateBestFit(fitness, dim);
return fitness;
}
/*! load an EXR file from disk */
Ref<Image> loadExr(const FileName& filename)
{
Imf::RgbaInputFile file (filename.c_str());
Imath::Box2i dw = file.dataWindow();
ssize_t width = dw.max.x - dw.min.x + 1;
ssize_t height = dw.max.y - dw.min.y + 1;
Imf::Array2D<Imf::Rgba> pixels(height, width);
file.setFrameBuffer (&pixels[0][0] - dw.min.x - dw.min.y * width, 1, width);
file.readPixels (dw.min.y, dw.max.y);
Ref<Image> img = new Image3f(width,height,filename);
if (file.lineOrder() == Imf::INCREASING_Y) {
for (ssize_t y=0; y<height; y++) {
for (ssize_t x=0; x<width; x++) {
Imf::Rgba c = pixels[y][x];
img->set(x,y,Color4(c.r,c.g,c.b,c.a));
}
}
}
else {
for (ssize_t y=0; y<height; y++) {
for (ssize_t x=0; x<width; x++) {
Imf::Rgba c = pixels[y][x];
img->set(x,height-y-1,Color4(c.r,c.g,c.b,c.a));
}
}
}
return img;
}
void loadFile(const FileName &fileName)
{
std::string extension = fileName.ext();
if (extension == "vtp")
loadVTKFile<vtkXMLPolyDataReader>(fileName.c_str());
}
bool isFileOnDisk(const FileName &fileName)
{
struct stat info;
// if we can stat the file, then it does exist
return (stat(fileName.c_str(), &info) == 0);
}
void ProgXrayImport::getDarkfield(const FileName &fnDir, Image<double> &IavgDark)
{
IavgDark.clear();
std::vector<FileName> listDir;
fnDir.getFiles(listDir);
for (size_t i=0; i<listDir.size(); i++)
if (listDir[i]=="darkfields")
{
std::cout << formatString("Getting darkfield from %s/darkfields",fnDir.c_str()) << " ..." << std::endl;
darkFix = true;
std::vector<FileName> listDirDark;
FileName(fnDir+"/darkfields").getFiles(listDirDark);
int N = 0;
for (size_t j=0; j<listDirDark.size(); j++)
{
if (!listDirDark[j].hasImageExtension())
continue;
Image<double> Iaux;
readAndCrop(fnDir+"/darkfields/"+listDirDark[j],Iaux, cropSizeX, cropSizeY);
if (N==0)
IavgDark()=Iaux();
else
IavgDark()+=Iaux();
N++;
}
if (N==0)
REPORT_ERROR(ERR_IO_NOTEXIST,"darkfields directory is empty");
IavgDark()*=1.0/N;
break;
}
}
int loadHairASCII(const FileName& fileName, OBJScene::HairSet* hairset, Vec3fa& offset)
{
/* open hair file */
FILE* f = fopen(fileName.c_str(),"r");
if (!f) throw std::runtime_error("could not open " + fileName.str());
char line[10000];
fgets(line,10000,f);
int numCurves = 0;
while (fgets(line,10000,f) && !feof(f))
{
/* comment */
if (line[0] == '#')
continue;
if (!strncmp(line,"Curve:",strlen("Curve:")))
{
char name[1000];
unsigned int tracks, points;
sscanf(line,"Curve: %s %d Tracks %d Points",name,&tracks,&points);
/* skip Tracks line */
fgets(line,10000,f);
const int vertex_start_id = hairset->v.size();
double x,y,z,w;
unsigned int id = 0;
for (int i=0; i<points; i++)
{
fgets(line,10000,f);
/* comment */
if (line[0] == '#' || !strncmp(line," Tracks:",strlen(" Tracks:")))
continue;
Vec3fa v;
if (i == 0) sscanf(line,"%d : Bezier %f %f %f %f",&id,&v.x,&v.y,&v.z,&v.w);
else sscanf(line,"%d : %f %f %f %f",&id,&v.x,&v.y,&v.z,&v.w);
//printf("%d %d : %f %f %f %f \n",id,vertex_start_id+id,v.x,v.y,v.z,v.w);
v.x-=offset.x;
v.y-=offset.y;
v.z-=offset.z;
hairset->v.push_back(v);
}
/* add indices to hair starts */
for (int i=0; i<points-1; i+=3)
hairset->hairs.push_back(OBJScene::Hair(vertex_start_id + i,numCurves));
if (id != points-1)
throw std::runtime_error("hair parsing error");
numCurves++;
}
}
fclose(f);
return numCurves;
}
// Continuous assignment ===================================================
double ProgNmaAlignment::performContinuousAssignment(const FileName &fnRandom,
int pyramidLevel) const {
// Perform alignment
const char * randStr = fnRandom.c_str();
String fnResults=formatString("%s_anglecont.xmd", randStr);
bool costSource=true;
String program = "xmipp_angular_continuous_assign";
String arguments =
formatString(
"-i %s_angledisc.xmd --ref %s_deformedPDB.vol -o %s --gaussian_Fourier %f --gaussian_Real %f --zerofreq_weight %f -v 0",
randStr, randStr, fnResults.c_str(), gaussian_DFT_sigma,
gaussian_Real_sigma, weight_zero_freq);
runSystem(program, arguments, false);
// Pick up results
MetaData DF(fnResults);
MDRow row;
DF.getRow(row, DF.firstObject());
row.getValue(MDL_ANGLE_ROT, trial(VEC_XSIZE(trial) - 5));
row.getValue(MDL_ANGLE_TILT, trial(VEC_XSIZE(trial) - 4));
row.getValue(MDL_ANGLE_PSI, trial(VEC_XSIZE(trial) - 3));
row.getValue(MDL_SHIFT_X, trial(VEC_XSIZE(trial) - 2));
trial(VEC_XSIZE(trial) - 2) *= pow(2.0, (double) pyramidLevel);
row.getValue(MDL_SHIFT_Y, trial(VEC_XSIZE(trial) - 1));
trial(VEC_XSIZE(trial) - 1) *= pow(2.0, (double) pyramidLevel);
double tempvar;
if (!costSource) {
row.getValue(MDL_MAXCC, tempvar);
tempvar = -tempvar;
} else
row.getValue(MDL_COST, tempvar);
return tempvar;
}
DataFile::DataFile (FileName const &fileName)
{
#ifdef DEBUG
std::cout << "open NetCDF file : " << fileName << std::endl;
#endif
int status = nc_open(fileName.c_str(),
NC_SHARE|NC_DISKLESS|NC_MMAP,
&handle_);
/*
* NC_SHARE : from doc : Since the buffering scheme is optimized
* for sequential access, programs that do not access data sequentially
* may see some performance improvement by setting the NC_SHARE flag.
*
* NC_DISKLESS : for allowing NC_MMAP. Side effect : any changes
* performed to the files won't be saved on exit. Not an issue for us.
*
* NC_MMAP : for mapping the file to virtual memory, and let the linux
* kernel do the RAM cache management for us. See `man mmap`.
* To use this flag, NetCDF must be compiled with ./configure --enable-mmap
* Ubuntu's libnetcdf doesn't include mmap support.
*/
if (status != NC_NOERR)
{
throw NetCdfException ("error opening " + fileName + ":\n"
+ nc_strerror(status));
}
#ifdef DEBUG
std::cout << "handle : #" << handle_ << std::endl;
#endif
}
vector<KeyFrame>
ModelLoaderMD3::loadKeyFrames(const FileName &fileName,
const FileName &skinName,
TextureFactory &textureFactory) const {
FILE * stream = fopen(fileName.c_str(), "rb");
VERIFY(stream && !ferror(stream), "MD3 failed to open: "+fileName.str());
Header header = readHeader(stream);
Frame *frames = readFrames(stream, header);
Tag *tags = readTags(stream, header);
Surface *surfaces = readSurfaces(stream, header);
fclose(stream);
vector<KeyFrame> keyFrames = buildKeyFrame(surfaces,
fileName,
skinName,
header,
textureFactory);
delete [] frames;
delete [] tags;
delete [] surfaces;
return keyFrames;
}
void run()
{
std::string extension=fnStack.getExtension();
if (extension=="mrc")
fnStack+=":mrcs";
else if (extension=="ali")
fnStack+=":mrcs";
std::ifstream fhAngles;
fhAngles.open(fnAngles.c_str());
if (!fhAngles)
REPORT_ERROR(ERR_IO_NOTOPEN,fnAngles);
Image<double> stack;
stack.read(fnStack, HEADER);
size_t xdim, ydim, zdim, ndim;
stack.getDimensions(xdim, ydim, zdim, ndim);
MetaData MD;
FileName fnSlice;
for (unsigned long slice = FIRST_IMAGE; slice <= ndim; slice++)
{
double angle;
fhAngles >> angle;
fnSlice.compose((int)slice,fnStack);
size_t objId=MD.addObject();
MD.setValue(MDL_IMAGE,fnSlice,objId);
MD.setValue(MDL_ANGLE_TILT,angle,objId);
MD.setValue(MDL_ENABLED,1,objId);
}
MD.write(fnOut);
}
void FileName::copyFile(const FileName & target) const
{
std::ifstream f1(this->c_str(), std::fstream::binary);
std::ofstream
f2(target.c_str(), std::fstream::trunc | std::fstream::binary);
f2 << f1.rdbuf();
}
void storeTga(const Ref<Image>& img, const FileName& fileName)
{
FILE* file = fopen(fileName.c_str(), "wb");
if (!file) THROW_RUNTIME_ERROR("error opening file " + fileName.str());
fwrite_uchar(0x00, file);
fwrite_uchar(0x00, file);
fwrite_uchar(0x02, file);
fwrite_ushort(0x0000, file);
fwrite_ushort(0x0000, file);
fwrite_ushort(0x0000, file);
fwrite_ushort(0x0000, file);
fwrite_uchar(0x00, file);
fwrite_ushort((unsigned short)img->width , file);
fwrite_ushort((unsigned short)img->height, file);
fwrite_uchar(0x18, file);
fwrite_uchar(0x20, file);
for (size_t y=0; y<img->height; y++) {
for (size_t x=0; x<img->width; x++) {
Color c = img->get(x,y);
fwrite_uchar((unsigned char)(clamp(c.b)*255.0f), file);
fwrite_uchar((unsigned char)(clamp(c.g)*255.0f), file);
fwrite_uchar((unsigned char)(clamp(c.r)*255.0f), file);
}
}
fclose(file);
}
void initialise()
{
// Get the MDs for both untilted and tilted particles
MDu.read(fn_unt);
MDt.read(fn_til);
if (MDu.numberOfObjects() != MDt.numberOfObjects())
REPORT_ERROR("Tiltpair plot ERROR: untilted and tilted STAR files have unequal number of entries.");
// Get the symmetry point group
int pgGroup, pgOrder;
SL.isSymmetryGroup(fn_sym, pgGroup, pgOrder);
SL.read_sym_file(fn_sym);
// Make postscript header
fh_eps.open(fn_eps.c_str(), std::ios::out);
if (!fh_eps)
REPORT_ERROR("Tiltpair plot ERROR: Cannot open " + fn_eps + " for output");
fh_eps << "%%!PS-Adobe-2.0\n";
fh_eps << "%% Creator: Tilt pair analysis \n";
fh_eps << "%% Pages: 1\n";
fh_eps << "0 setgray\n";
fh_eps << "0.1 setlinewidth\n";
// Draw circles on postscript: 250pixels=plot_max_tilt
fh_eps << "300 400 83 0 360 arc closepath stroke\n";
fh_eps << "300 400 167 0 360 arc closepath stroke\n";
fh_eps << "300 400 250 0 360 arc closepath stroke\n";
fh_eps << "300 150 newpath moveto 300 650 lineto stroke\n";
fh_eps << "50 400 newpath moveto 550 400 lineto stroke\n";
}
int loadHairBin(const FileName& fileName, OBJScene::HairSet* hairset, Vec3fa& offset)
{
FILE* fin = fopen(fileName.c_str(),"rb");
if (!fin) throw std::runtime_error("could not open " + fileName.str());
int magick;
fread(&magick,sizeof(int),1,fin);
if (magick != hair_bin_magick)
throw std::runtime_error("invalid binary hair file " + fileName.str());
int numHairs;
fread(&numHairs,sizeof(int),1,fin);
int numPoints;
fread(&numPoints,sizeof(int),1,fin);
int numSegments;
fread(&numSegments,sizeof(int),1,fin);
hairset->v.resize(numPoints);
hairset->hairs.resize(numSegments);
if (numPoints) fread(&hairset->v[0],sizeof(Vec3fa),numPoints,fin);
if (numSegments) fread(&hairset->hairs[0],sizeof(OBJScene::Hair),numSegments,fin);
fclose(fin);
for (size_t i=0; i<numPoints; i++) {
hairset->v[i].x-=offset.x;
hairset->v[i].y-=offset.y;
hairset->v[i].z-=offset.z;
}
return numHairs;
}
void createDirectory(const FileName &path)
{
int result = -1;
#ifdef _WIN32
result = _mkdir(path.c_str());
#else
result = mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
#endif
if(result < 0)
{
if(errno != EEXIST) // directory exists is OK
{
perror("mkdir() failed");
ERR(string("mkdir() failed: ") + strerror(errno));
}
}
}
/*! read PFM file from disk */
Ref<Image> loadPFM(const FileName& fileName)
{
/* open PPM file */
FILE* file = fopen(fileName.c_str(), "rb");
if (!file) THROW_RUNTIME_ERROR("cannot open " + fileName.str());
/* read file type */
char type[8];
if (fscanf(file, "%7s", type) != 1)
THROW_RUNTIME_ERROR("Error reading " + fileName.str());
/* skip comment lines */
while (readCommentLine(file)) {};
/* read width, height, and maximal color value */
int width, height;
float maxColor;
if (fscanf(file, "%i %i %f", &width, &height, &maxColor) != 3)
THROW_RUNTIME_ERROR("Error reading " + fileName.str());
/* Check for big endian PFM file */
if (maxColor > 0.0f) {
fclose(file);
THROW_RUNTIME_ERROR("Big endian PFM files not supported");
}
float rcpMaxColor = -1.0f/float(maxColor);
/* get return or space */
fgetc(file);
/* create image and fill with data */
Ref<Image> img = new Image3f(width,height,fileName);
/* image in binary format 32 bit */
if (!strcmp(type, "PF"))
{
float rgb[3];
for (ssize_t y=0; y<height; y++) {
for (ssize_t x=0; x<width; x++) {
if (fread(rgb,sizeof(rgb),1,file) != 1)
THROW_RUNTIME_ERROR("Error reading " + fileName.str());
img->set(x,y,Color4(float(rgb[0])*rcpMaxColor,float(rgb[1])*rcpMaxColor,float(rgb[2])*rcpMaxColor,1.0f));
}
}
}
/* invalid magic value */
else {
fclose(file);
THROW_RUNTIME_ERROR("Invalid magic value in PFM file");
}
fclose(file);
return img;
}
//-------------------------------------------------------------------------
void ULongVector::save(const FileName& f) {
try {
ofstream outputMat(f.c_str(),ios::out|ios::binary);
if(!outputMat)
throw IOException("Cannot open file", __FILE__, __LINE__,f);
outputMat.write((char*)&_size,sizeof(_size));
outputMat.write((char*)_array,_size*sizeof(unsigned long));
outputMat.close();
}
catch (Exception& e) {cout << e.toString().c_str() << endl;}
}
void SoundSystem::playMusic(const FileName &fileName)
{
stopMusic();
if(!mute && fileName!=FileName("none") && fileName!=FileName(""))
{
musicStream = FSOUND_Stream_Open(fileName.c_str(),
FSOUND_LOOP_NORMAL,
0, 0);
musicChannel = FSOUND_Stream_Play(FSOUND_FREE, musicStream);
TRACE("Playing music: " + fileName.str());
}
}
// Create deformed PDB =====================================================
FileName ProgNmaAlignment::createDeformedPDB(int pyramidLevel) const {
String program;
String arguments;
FileName fnRandom;
fnRandom.initUniqueName(nameTemplate,fnOutDir);
const char * randStr = fnRandom.c_str();
program = "xmipp_pdb_nma_deform";
arguments = formatString(
"--pdb %s -o %s_deformedPDB.pdb --nma %s --deformations ",
fnPDB.c_str(), randStr, fnModeList.c_str());
for (size_t i = 0; i < VEC_XSIZE(trial) - 5; ++i)
arguments += floatToString(trial(i)) + " ";
runSystem(program, arguments, false);
program = "xmipp_volume_from_pdb";
arguments = formatString(
"-i %s_deformedPDB.pdb --size %i --sampling %f -v 0", randStr,
imgSize, sampling_rate);
if (do_centerPDB)
arguments.append(" --centerPDB ");
if (useFixedGaussian) {
arguments.append(" --intensityColumn Bfactor --fixed_Gaussian ");
if (sigmaGaussian >= 0)
arguments += formatString("%f",sigmaGaussian);
}
//else
//arguments +=" --poor_Gaussian"; // Otherwise, a detailed conversion of the atoms takes too long in this context
progVolumeFromPDB->read(arguments);
progVolumeFromPDB->tryRun();
if (do_FilterPDBVol) {
program = "xmipp_transform_filter";
arguments = formatString(
"-i %s_deformedPDB.vol --sampling %f --fourier low_pass %f -v 0",
randStr, sampling_rate, cutoff_LPfilter);
runSystem(program, arguments, false);
}
if (pyramidLevel != 0) {
Image<double> I;
FileName fnDeformed = formatString("%s_deformedPDB.vol",randStr);
I.read(fnDeformed);
selfPyramidReduce(BSPLINE3, I(), pyramidLevel);
I.write(fnDeformed);
}
return fnRandom;
}
/*! store an EXR file to disk */
void storeExr(const Ref<Image>& img, const FileName& filename)
{
Imf::Array2D<Imf::Rgba> pixels(img->height,img->width);
for (size_t y=0; y<img->height; y++) {
for (size_t x=0; x<img->width; x++) {
const Color4 c = img->get(x,y);
pixels[y][x] = Imf::Rgba(c.r,c.g,c.b,c.a);
}
}
Imf::RgbaOutputFile file(filename.c_str(), img->width, img->height, Imf::WRITE_RGBA);
file.setFrameBuffer(&pixels[0][0], 1, img->width);
file.writePixels(img->height);
}
/*! store PFM file to disk */
void storePFM(const Ref<Image>& img, const FileName& fileName)
{
FILE* file = fopen(fileName.c_str(), "wb");
if (!file) THROW_RUNTIME_ERROR("cannot open file " + fileName.str());
fprintf(file,"PF\n%i %i\n%f\n", int(img->width), int(img->height), -1.0f);
float rgb[3];
for (size_t y=0; y<img->height; y++) {
for (size_t x=0; x<img->width; x++) {
Color4 c = img->get(x,y);
rgb[0] = c.r; rgb[1] = c.g; rgb[2] = c.b;
fwrite(rgb,sizeof(rgb),1,file);
}
}
fclose(file);
}
/*! store PPM file to disk */
void storePPM(const Ref<Image>& img, const FileName& fileName)
{
FILE* file = fopen(fileName.c_str(), "wb");
if (!file) THROW_RUNTIME_ERROR("cannot open file " + fileName.str());
fprintf(file,"P6\n%i %i\n255\n", int(img->width), int(img->height));
for (size_t y=0; y<img->height; y++) {
for (size_t x=0; x<img->width; x++) {
const Color4 c = img->get(x,y);
fputc((unsigned char)(clamp(c.r)*255.0f), file);
fputc((unsigned char)(clamp(c.g)*255.0f), file);
fputc((unsigned char)(clamp(c.b)*255.0f), file);
}
}
fclose(file);
}
bool State::parseFile(const FileName& fileName)
{
FILE* f = fopen(fileName.c_str(),"r");
if (f == nullptr) return false;
Ref<Stream<int> > file = new FileStream(f,fileName);
std::vector<std::string> syms;
for (size_t i=0; i<sizeof(symbols)/sizeof(void*); i++)
syms.push_back(symbols[i]);
Ref<TokenStream> cin = new TokenStream(new LineCommentFilter(file,"#"),
TokenStream::alpha+TokenStream::ALPHA+TokenStream::numbers+"_.",
TokenStream::separators,syms);
parse(cin);
return true;
}
bool File::openStream(const FileName &fileName, FILE_MODE mode)
{
this->fileName = fileName;
const char *pszMode = getModeString(mode);
stream = fopen(fileName.c_str(), pszMode);
if(stream==0 || ferror(stream))
{
// Failed to open file stream
return false;
}
return true;
}
//-------------------------------------------------------------------------
void XList::save(const FileName& f, const Config& c) const
{
std::ofstream ff(f.c_str(), std::ios::out);
if (!ff)
throw IOException("Cannot open file", __FILE__, __LINE__, f);
for (unsigned long i=0; i<getLineCount(); i++)
{
XLine& line = _vector.getObject(i);
unsigned long count = line.getElementCount();
for (unsigned long j=0; j<count; j++)
{
ff << line.getElement(j, false); // false = does not change current seg
if (j+1<count)
ff << " ";
}
ff << std::endl;
}
}
Ref<Image> loadMagick(const FileName& fileName)
{
Magick::Image image(fileName.c_str());
Image* out = new Image4uc(image.columns(),image.rows(),fileName);
float rcpMaxRGB = 1.0f/float(MaxRGB);
Magick::Pixels pixel_cache(image);
Magick::PixelPacket* pixels = pixel_cache.get(0,0,out->width,out->height);
switch (image.orientation())
{
case UndefinedOrientation:
case TopLeftOrientation: {
for (size_t y=0; y<out->height; y++) {
for (size_t x=0; x<out->width; x++) {
Color4 c;
c.r = float(pixels[y*out->width+x].red)*rcpMaxRGB;
c.g = float(pixels[y*out->width+x].green)*rcpMaxRGB;
c.b = float(pixels[y*out->width+x].blue)*rcpMaxRGB;
c.a = float(pixels[y*out->width+x].opacity)*rcpMaxRGB;
out->set(x,out->height-y-1,c);
}
}
break;
}
case BottomLeftOrientation: {
for (size_t y=0; y<out->height; y++) {
for (size_t x=0; x<out->width; x++) {
Color4 c;
c.r = float(pixels[y*out->width+x].red)*rcpMaxRGB;
c.g = float(pixels[y*out->width+x].green)*rcpMaxRGB;
c.b = float(pixels[y*out->width+x].blue)*rcpMaxRGB;
c.a = float(pixels[y*out->width+x].opacity)*rcpMaxRGB;
out->set(x,y,c);
}
}
break;
}
default: {
throw std::runtime_error("not supported image orientation");
}
}
return out;
}
//-------------------------------------------------------------------------
void ULongVector::load(const FileName& f) {
try {
ifstream inputVect(f.c_str(),ios::in|ios::binary);
if(!inputVect)
throw IOException("Cannot open file", __FILE__, __LINE__,f);
inputVect.read((char*)&_size,sizeof(_size));
if (_capacity != 0) delete[] _array;
_array = new unsigned long[_size];
if (!_array)
throw Exception("Memory allocation exception", __FILE__, __LINE__);
_capacity=_size;
inputVect.read((char*)_array,_size*sizeof(unsigned long));
inputVect.close();
}
catch (Exception& e) {cout << e.toString().c_str() << endl;}
}
