void init(void) { load("libEGL.so.1"); initX(); eglExtensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); if (eglExtensions && checkExtension("EGL_EXT_platform_x11", eglExtensions)) { Attributes<EGLint> attribs; attribs.add(EGL_PLATFORM_X11_SCREEN_EXT, screen); attribs.add(EGL_NONE); eglDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_X11_EXT, display, attribs); } else { eglDisplay = eglGetDisplay((EGLNativeDisplayType)display); } if (eglDisplay == EGL_NO_DISPLAY) { std::cerr << "error: unable to get EGL display\n"; XCloseDisplay(display); exit(1); } EGLint major, minor; if (!eglInitialize(eglDisplay, &major, &minor)) { std::cerr << "error: unable to initialize EGL display\n"; XCloseDisplay(display); exit(1); } eglExtensions = eglQueryString(eglDisplay, EGL_EXTENSIONS); has_EGL_KHR_create_context = checkExtension("EGL_KHR_create_context", eglExtensions); }
void cESBTL::pdbTransRotTrans(const std::string& fileIn, const std::string& fileOut, const cVector3<double>& offset1, const cVector3<double>& angle, const cVector3<double>& offset2) { checkExtension(fileIn); checkExtension(fileOut); // input ESBTL::PDB_line_selector pdbSelector; std::vector<ESBTL::Default_system> pdbSystems; ESBTL::All_atom_system_builder<ESBTL::Default_system> pdbBuilder(pdbSystems, pdbSelector.max_nb_systems()); require(ESBTL::read_a_pdb_file(fileIn, pdbSelector, pdbBuilder, Occupancy_policy_all()), "cannot read PDB file"); require(!pdbSystems.empty(), "No PDB system"); require( pdbSystems.size() == 1, "More than one PDB system: pdbSystems.size() = " + num2str(pdbSystems.size())); require(!pdbSystems[0].has_no_model(), "No model in 1st PDB system"); require( pdbSystems[0].number_of_models() == 1, "More than one model in 1st PDB system: pdbSystems[0].number_of_models() = " + num2str(pdbSystems[0].number_of_models())); // output std::ofstream output(fileOut.c_str()); assure(output); // translate - rotate - translate cVector3<double> pointRot; cMatrix33<double> matRot; transform_rotmat(angle[0], angle[1], angle[2], matRot[0][0], matRot[0][1], matRot[0][2], matRot[1][0], matRot[1][1], matRot[1][2], matRot[2][0], matRot[2][1], matRot[2][2], ROT3D_RIGHT_ZYZ); for (ESBTL::Default_system::Models_iterator iterModel = pdbSystems[0].models_begin(); iterModel != pdbSystems[0].models_end(); iterModel++) { const ESBTL::Default_system::Model& model = *iterModel; for (ESBTL::Default_system::Model::Atoms_const_iterator iterAtom = model.atoms_begin(); iterAtom != model.atoms_end(); iterAtom++) { ESBTL::Default_system::Atom atom(*iterAtom); pointRot = matRot * cVector3<double>(atom.x() + offset1[0], atom.y() + offset1[1], atom.z() + offset1[2]); atom.x() = pointRot[0] + offset2[0]; atom.y() = pointRot[1] + offset2[1]; atom.z() = pointRot[2] + offset2[2]; output << ESBTL::PDB::get_atom_pdb_format(atom) << "\n"; } } }
QStringList BBActionAdd::addDirectory(const QString& dirname) { BBDEBUG << dirname; QFileInfo info(dirname); if (!info.exists()) { return QStringList(); } QStringList list; if (dirname != BBSettings::instance()->directory() && checkExtension(info)) list << dirname; if (info.isDir()) { QDir dir(dirname); BBSvn::removeDir(dir); QFileInfoList files = dir.entryInfoList(QDir::AllEntries | QDir::Hidden | QDir::NoSymLinks); foreach (QFileInfo file, files) { if (file.fileName().startsWith(".")) continue; list << addDirectory(file.absoluteFilePath()); } }
void Renderer::checkGlCaps() { if(glActiveTexture == NULL) { string message; message += "Your system supports OpenGL version \""; message += getGlVersion() + string("\"\n"); message += "MegaGlest needs a version that supports\n"; message += "glActiveTexture (OpenGL 1.3) or the ARB_multitexture extension."; throw megaglest_runtime_error(message.c_str()); } //opengl 1.3 //if(!isGlVersionSupported(1, 3, 0)) { if(glewIsSupported("GL_VERSION_1_3") == false) { string message; message += "Your system supports OpenGL version \""; message += getGlVersion() + string("\"\n"); message += "MegaGlest needs at least version 1.3 to work\n"; message += "You may solve this problem by installing your latest video card drivers"; throw megaglest_runtime_error(message.c_str()); } //opengl 1.4 or extension //if(isGlVersionSupported(1, 4, 0) == false) { if(glewIsSupported("GL_VERSION_1_4") == false) { checkExtension("GL_ARB_texture_env_crossbar", "MegaGlest"); } }
void cESBTL::pdbReadAtom (const std::string& fileIn, cSetPoint3<double>& atomList, const std::string& atomName) { checkExtension(fileIn); ESBTL::PDB_line_selector pdbSelector; std::vector<ESBTL::Default_system> pdbSystems; ESBTL::All_atom_system_builder<ESBTL::Default_system> pdbBuilder(pdbSystems, pdbSelector.max_nb_systems()); require(ESBTL::read_a_pdb_file(fileIn, pdbSelector, pdbBuilder, Occupancy_policy_all()), "cannot read PDB file"); require(!pdbSystems.empty(), "No PDB system"); require( pdbSystems.size() == 1, "More than one PDB system: pdbSystems.size() = " + num2str(pdbSystems.size())); require(!pdbSystems[0].has_no_model(), "No model in 1st PDB system"); require( pdbSystems[0].number_of_models() == 1, "More than one model in PDB system: pdbSystems[0].number_of_models() = " + num2str(pdbSystems[0].number_of_models())); for (ESBTL::Default_system::Models_iterator iterModel = pdbSystems[0].models_begin(); iterModel != pdbSystems[0].models_end(); iterModel++) { const ESBTL::Default_system::Model& model = *iterModel; for (ESBTL::Default_system::Model::Atoms_const_iterator iterAtom = model.atoms_begin(); iterAtom != model.atoms_end(); iterAtom++) { if ((atomName != "" && iterAtom->atom_name() == atomName) || atomName == "") { atomList.push_back(cVector3<double>(iterAtom->x(),iterAtom->y(),iterAtom->z())); } } } }
void utils::enableVSyncWin(int i) { #ifdef _WIN32 const GLubyte* glExt = glGetString(GL_EXTENSIONS); if(checkExtension("WGL_EXT_swap_control")) { PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT"); wglSwapIntervalEXT(i); } #endif }
void cESBTL::pdbTranslate(const std::string& fileIn, const std::string& fileOut, const cVector3<double>& offset) { checkExtension(fileIn); checkExtension(fileOut); // input ESBTL::PDB_line_selector pdbSelector; std::vector<ESBTL::Default_system> pdbSystems; ESBTL::All_atom_system_builder<ESBTL::Default_system> pdbBuilder(pdbSystems, pdbSelector.max_nb_systems()); require(ESBTL::read_a_pdb_file(fileIn, pdbSelector, pdbBuilder, Occupancy_policy_all()), "cannot read PDB file"); require(!pdbSystems.empty(), "No PDB system"); require( pdbSystems.size() == 1, "More than one PDB system: pdbSystems.size() = " + num2str(pdbSystems.size())); require(!pdbSystems[0].has_no_model(), "No model in 1st PDB system"); require( pdbSystems[0].number_of_models() == 1, "More than one model in 1st PDB system: pdbSystems[0].number_of_models() = " + num2str(pdbSystems[0].number_of_models())); // output std::ofstream output(fileOut.c_str()); assure(output); // translate for (ESBTL::Default_system::Models_iterator iterModel = pdbSystems[0].models_begin(); iterModel != pdbSystems[0].models_end(); iterModel++) { const ESBTL::Default_system::Model& model = *iterModel; for (ESBTL::Default_system::Model::Atoms_const_iterator iterAtom = model.atoms_begin(); iterAtom != model.atoms_end(); iterAtom++) { ESBTL::Default_system::Atom atom(*iterAtom); atom.x() += offset[0]; atom.y() += offset[1]; atom.z() += offset[2]; output << ESBTL::PDB::get_atom_pdb_format(atom) << "\n"; } } }
void cESBTL::pdbExtractChain(const std::string& fileIn, const std::string& fileOut, const std::string& chainIDs) { checkExtension(fileIn); checkExtension(fileOut); // input ESBTL::PDB_line_selector pdbSelector; std::vector<ESBTL::Default_system> pdbSystems; ESBTL::All_atom_system_builder<ESBTL::Default_system> pdbBuilder(pdbSystems, pdbSelector.max_nb_systems()); require(ESBTL::read_a_pdb_file(fileIn, pdbSelector, pdbBuilder, Occupancy_policy_all()), "cannot read PDB file"); require(!pdbSystems.empty(), "No PDB system"); require( pdbSystems.size() == 1, "More than one PDB system: pdbSystems.size() = " + num2str(pdbSystems.size())); require(!pdbSystems[0].has_no_model(), "No model in 1st PDB system"); require( pdbSystems[0].number_of_models() == 1, "More than one model in 1st PDB system: pdbSystems[0].number_of_models() = " + num2str(pdbSystems[0].number_of_models())); // output std::ofstream output(fileOut.c_str()); assure(output); // selection ESBTL::Select_by_chainids pdbSelectorChainIDs(chainIDs); for (ESBTL::Default_system::Models_iterator iterModel = pdbSystems[0].models_begin(); iterModel != pdbSystems[0].models_end(); iterModel++) { const ESBTL::Default_system::Model& model = *iterModel; for (Restrict_iterator iterAtom = ESBTL::make_selected_atom_iterator(model.atoms_begin(),pdbSelectorChainIDs); iterAtom != ESBTL::make_selected_atom_iterator<ESBTL::Select_by_chainids>(model.atoms_end()); iterAtom++) { output << ESBTL::PDB::get_atom_pdb_format(*iterAtom) << "\n"; } output.close(); } }
void cCCP4<T>::readHeader(const std::string& fileName, cMapHeader& header) { const std::string funcName("void cCCP4::readHeader(" "const std::string& fileName, " "cMapHeader& header)"); checkExtension(fileName); CMap_io::CMMFile *fileHandle = (CMap_io::CMMFile *) CMap_io::ccp4_cmap_open(fileName.c_str(), O_RDONLY); require(fileHandle, funcName + ": could not open CCP4 file " + fileName); // save header information header.file_name = fileName; header.data_mode = fileHandle->data_mode; header.spacegroup = fileHandle->spacegroup; header.cell_dim[0] = fileHandle->cell[0]; header.cell_dim[1] = fileHandle->cell[1]; header.cell_dim[2] = fileHandle->cell[2]; header.cell_angle[0] = fileHandle->cell[3]; header.cell_angle[1] = fileHandle->cell[4]; header.cell_angle[2] = fileHandle->cell[5]; header.map_dim[0] = fileHandle->map_dim[0]; header.map_dim[1] = fileHandle->map_dim[1]; header.map_dim[2] = fileHandle->map_dim[2]; header.origin[0] = fileHandle->origin[0]; header.origin[1] = fileHandle->origin[1]; header.origin[2] = fileHandle->origin[2]; header.cell_grid[0] = fileHandle->cell_grid[0]; header.cell_grid[1] = fileHandle->cell_grid[1]; header.cell_grid[2] = fileHandle->cell_grid[2]; header.axes_order[0] = fileHandle->axes_order[0]; header.axes_order[1] = fileHandle->axes_order[1]; header.axes_order[2] = fileHandle->axes_order[2]; ccp4_cmap_get_mapstats(fileHandle, &header.min, &header.max, &header.mean, &header.rms); header.sym_byte = 80 * ccp4_cmap_num_symop(fileHandle); ccp4_cmap_close(fileHandle); }
void shLoadExtensions(VGContext *c) { const char *ext = (const char*)glGetString(GL_EXTENSIONS); LOGD("GL_EXTENSIONS = %s\n", ext); int i; glGetIntegerv(GL_STENCIL_BITS, &i); LOGD("GL_STENCIL_BITS = %d\n", i); c->gl_stencil_bits = i; /* GL_TEXTURE_CLAMP_TO_EDGE */ if (checkExtension(ext, "GL_EXT_texture_edge_clamp")) c->isGLAvailable_ClampToEdge = 1; else if (checkExtension(ext, "GL_SGIS_texture_edge_clamp")) c->isGLAvailable_ClampToEdge = 1; else /* Unavailable */ c->isGLAvailable_ClampToEdge = 0; /* GL_TEXTURE_MIRRORED_REPEAT */ if (checkExtension(ext, "GL_ARB_texture_mirrored_repeat")) c->isGLAvailable_MirroredRepeat = 1; else if(checkExtension(ext, "GL_IBM_texture_mirrored_repeat")) c->isGLAvailable_MirroredRepeat = 1; else /* Unavailable */ c->isGLAvailable_MirroredRepeat = 0; /* glActiveTexture, glMultiTexCoord1f */ if (checkExtension(ext, "GL_ARB_multitexture")) { c->isGLAvailable_Multitexture = 1; c->pglActiveTexture = (SH_PGLACTIVETEXTURE) shGetProcAddress("glActiveTextureARB"); c->pglMultiTexCoord1f = (SH_PGLMULTITEXCOORD1F) shGetProcAddress("glMultiTexCoord1fARB"); c->pglMultiTexCoord2f = (SH_PGLMULTITEXCOORD2F) shGetProcAddress("glMultiTexCoord2fARB"); if (c->pglActiveTexture == NULL || c->pglMultiTexCoord1f == NULL || c->pglMultiTexCoord2f == NULL) c->isGLAvailable_Multitexture = 0; }else{ /* Unavailable */ c->isGLAvailable_Multitexture = 0; c->pglActiveTexture = (SH_PGLACTIVETEXTURE)fallbackActiveTexture; c->pglMultiTexCoord1f = (SH_PGLMULTITEXCOORD1F)fallbackMultiTexCoord1f; c->pglMultiTexCoord2f = (SH_PGLMULTITEXCOORD2F)fallbackMultiTexCoord2f; } /* Non-power-of-two textures */ if (checkExtension(ext, "GL_ARB_texture_non_power_of_two")) c->isGLAvailable_TextureNonPowerOfTwo = 1; else /* Unavailable */ c->isGLAvailable_TextureNonPowerOfTwo = 0; }
void init(void) { eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (eglDisplay == EGL_NO_DISPLAY) { std::cerr << "error: unable to get EGL display\n"; exit(1); } EGLint major, minor; if (!eglInitialize(eglDisplay, &major, &minor)) { std::cerr << "error: unable to initialize EGL display\n"; exit(1); } eglExtensions = eglQueryString(eglDisplay, EGL_EXTENSIONS); has_EGL_KHR_create_context = checkExtension("EGL_KHR_create_context", eglExtensions); }
void init(void) { display = XOpenDisplay(NULL); if (!display) { std::cerr << "error: unable to open display " << XDisplayName(NULL) << "\n"; exit(1); } screen = DefaultScreen(display); int major = 0, minor = 0; glXQueryVersion(display, &major, &minor); glxVersion = (major << 8) | minor; extensions = glXQueryExtensionsString(display, screen); has_GLX_ARB_create_context = checkExtension("GLX_ARB_create_context", extensions); }
//--------------------------------------------------------------------------- void __fastcall TForm2::Abrir2Click(TObject *Sender) { if (!abierto){ open->Execute(); archivoOpen=open->FileName; if (archivoOpen!="NULL") if (!checkExtension()) archivoOpen="NULL"; else{ //la extension era correcta abierto= true; open->CleanupInstance(); } } else{ Form5->setError(3); Form5->setVisible(); } }
static QStringList parseUrls(const QStringList &urls, bool percentEncoded) { QStringList useable; foreach (const QString &path, urls) { QUrl u=percentEncoded ? QUrl::fromPercentEncoding(path.toUtf8()) : QUrl(path); #if defined ENABLE_DEVICES_SUPPORT && (defined CDDB_FOUND || defined MUSICBRAINZ5_FOUND) QString cdDevice=AudioCdDevice::getDevice(u); if (!cdDevice.isEmpty()) { DevicesModel::self()->playCd(cdDevice); } else #endif if (QLatin1String("http")==u.scheme()) { useable.append(u.toString()); } else if ((u.scheme().isEmpty() || QLatin1String("file")==u.scheme()) && checkExtension(u.path())) { if (!HttpServer::self()->forceUsage() && MPDConnection::self()->localFilePlaybackSupported() && !u.path().startsWith(QLatin1String("/media/"))) { useable.append(QLatin1String("file://")+u.path()); } else if (HttpServer::self()->isAlive()) { useable.append(HttpServer::self()->encodeUrl(u.path())); } } }
void Video::loadVideos() { const char *path = "/Users/Jobs/Documents/Xcode/HolumV0.1/HolumV0.1/Resource Files"; string videoPath(path); struct dirent *entry; DIR *dp; dp = opendir(path); if(dp == NULL) { cout << "Errore 004: Il percorso della directory video non esiste o non è definito."; return -1; } while((entry = readdir(dp))) { string videoName = string(entry->d_name); int videoNameLen = strlen(videoName.c_str()); if(checkExtension(videoName, videoNameLen)) { videoPath += "/" + videoName; FileVideo fv(videoPath, videoName.substr(0, videoName.find("."))); videoFiles.push_back(fv); } } closedir(dp); }
static void Init(void) { const GLubyte *extensions; GLboolean hasDebugExtension; extensions = glGetString(GL_EXTENSIONS); checkGlError("glGetString(GL_EXTENSIONS)"); hasDebugExtension = checkExtension(debugExtensionString, extensions); if (GLEW_VERSION_3_0) { GLboolean hasDebugExtension3 = GL_FALSE; GLint i; GLint num_extensions = 0; glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions); checkGlError("glGetIntegerv(GL_NUM_EXTENSIONS)"); for (i = 0; i < num_extensions; ++i) { const char *extension; extension = (const char *)glGetStringi(GL_EXTENSIONS, i); checkGlError("glGetStringi(GL_EXTENSIONS, i)"); if (strlen(extension) == 0) { fprintf(stderr, "error: glGetStringi returned empty string\n"); exit(1); } if (strcmp(extension, debugExtensionString) == 0) { hasDebugExtension3 = GL_TRUE; } } if (hasDebugExtension != hasDebugExtension3) { fprintf(stderr, "error: %s not consistently supported by GL3\n", debugExtensionString); exit(1); } } glewInit(); if (hasDebugExtension != glewIsSupported(debugExtensionString)) { fprintf(stderr, "error: %s not consistently supported by GLEW\n", debugExtensionString); exit(1); } if (hasDebugExtension) { switch (debugExtension) { case KHR_DEBUG: debugMessageInsert = khrDebugMessageInsert; pushDebugGroup = khrPushDebugGroup; popDebugGroup = khrPopDebugGroup; objectLabel = glObjectLabel; getObjectLabel = glGetObjectLabel; break; case ARB_DEBUG_OUTPUT: debugMessageInsert = arbDebugMessageInsert; break; case AMD_DEBUG_OUTPUT: debugMessageInsert = amdDebugMessageInsert; break; case EXT_DEBUG_MARKER: debugMessageInsert = extDebugMessageInsert; pushDebugGroup = extPushDebugGroup; popDebugGroup = extPopDebugGroup; break; } } else { fprintf(stderr, "warning: %s not supported\n", debugExtensionString); } debugMessageInsert(-1, __FUNCTION__); pushDebugGroup(-1, __FUNCTION__); glClearColor(0.3, 0.1, 0.3, 1.0); popDebugGroup(); // texture label GLuint texture = 0; glGenTextures(1, &texture); objectLabel(GL_TEXTURE, texture, -1, "texture"); glBindTexture(GL_TEXTURE_2D, texture); glTexImage2D(GL_TEXTURE_2D, 0, 3, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); // framebuffer color attachment label GLuint framebuffer = 0; glGenFramebuffers(1, &framebuffer); glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); glBindFramebuffer(GL_FRAMEBUFFER, 0); }
void cCCP4<T>::readData(const std::string& fileName, cData3<T>& object, cMapHeader& header) { const std::string funcName("void cCCP4::readData(const std::string& fileName, " "cData3<T>& object, cMapHeader& header)"); checkExtension(fileName); CMap_io::CMMFile *fileHandle = (CMap_io::CMMFile *) CMap_io::ccp4_cmap_open(fileName.c_str(), O_RDONLY); require(fileHandle, funcName + ": could not open CCP4 file " + fileName); // allocate new memory object.memReAlloc(cVector3<size_t>((size_t) fileHandle->map_dim[0], (size_t) fileHandle->map_dim[1], (size_t) fileHandle->map_dim[2])); // seek to data starting point ccp4_cmap_seek_data(fileHandle, (CCP4_HEADER_SIZE + header.sym_byte) / 4, SEEK_SET); /*ccp4_cmap_seek_data(fileHandle, 256+20*ccp4_cmap_num_symop(fileHandle), SEEK_SET);*/ int8_t *dataInt8 = NULL; int16_t *dataInt16 = NULL; float *dataFloat = NULL; switch (fileHandle->data_mode) { case 0: // int8 array_new(dataInt8, object.getNelement()); ccp4_cmap_read_data(fileHandle, (void *) dataInt8, (int) object.getNelement()); array_index_col2row(dataInt8, object.getAddrData(), object.getNrow(), object.getNcol(), object.getNsec()); array_delete(dataInt8); break; case 1: // int16 array_new(dataInt16, object.getNelement()); ccp4_cmap_read_data(fileHandle, (void *) dataInt16, (int) object.getNelement()); array_index_col2row(dataInt16, object.getAddrData(), object.getNrow(), object.getNcol(), object.getNsec()); array_delete(dataInt16); break; case 2: // float32 array_new(dataFloat, object.getNelement()); ccp4_cmap_read_data(fileHandle, (void *) dataFloat, (int) object.getNelement()); array_index_col2row(dataFloat, object.getAddrData(), object.getNrow(), object.getNcol(), object.getNsec()); array_delete(dataFloat); break; default: ERROR(funcName, "unsupported data mode in reading " + fileName); } ccp4_cmap_close(fileHandle); }
void cMRC<T>::readHeader(const std::string& fileName, cMapHeader& header) { const std::string funcName("void cMRC::readHeader(" "const std::string& fileName, " "cMapHeader& header)"); checkExtension(fileName); std::ifstream fileHandle; fileHandle.open(fileName.c_str(), std::ifstream::binary); assure(fileHandle, fileName.c_str()); int map_dim[3], data_mode, origin[3], cell_grid[3], axes_order[3]; float cell_dim[3], cell_angle[3]; float density_min, density_max, density_mean; int spacegroup, sym_byte; char mapStamp[] = " "; fileHandle.read((char*) map_dim, 3*sizeof(int)); // NX, NY, NZ fileHandle.read((char*) &data_mode, sizeof(int)); // MODE fileHandle.read((char*) origin, 3*sizeof(int)); // NXSTART, NYSTART, NZSTART fileHandle.read((char*) cell_grid, 3*sizeof(int)); // MX, MY, MZ fileHandle.read((char*) cell_dim, 3*sizeof(float)); // CELLA fileHandle.read((char*) cell_angle, 3*sizeof(float)); // CELLB fileHandle.read((char*) axes_order, 3*sizeof(int)); // MAPC, MAPR, MAPS fileHandle.read((char*) &density_min, sizeof(float)); // DMIN fileHandle.read((char*) &density_max, sizeof(float)); // DMAX fileHandle.read((char*) &density_mean, sizeof(float)); // DMEAN fileHandle.read((char*) &spacegroup, sizeof(int)); // ISPG fileHandle.read((char*) &sym_byte, sizeof(int)); // NSYMBT fileHandle.seekg(208, std::ios::beg); fileHandle.read((char*) mapStamp, 4*sizeof(char)); // MAP // check for the need of byte swapping header.edian_swap = false; if (map_dim[0] < 0 || map_dim[0] > 100000 || map_dim[1] < 0 || map_dim[1] > 100000 || map_dim[2] < 0 || map_dim[2] > 100000) { header.edian_swap = true; } if (header.edian_swap) { swap4_aligned(map_dim, 3); swap4_aligned(&data_mode, 1); swap4_aligned(origin, 3); swap4_aligned(cell_grid, 3); swap4_aligned(cell_dim, 3); swap4_aligned(cell_angle, 3); swap4_aligned(axes_order, 3); swap4_aligned(&density_min, 1); swap4_aligned(&density_max, 1); swap4_aligned(&density_mean, 1); swap4_aligned(&spacegroup, 1); swap4_aligned(&sym_byte, 1); swap4_aligned(mapStamp, 1); } // check data mode and 'MAP' stamp require(data_mode >=0 || data_mode <= 2, funcName + ": non-supported data type (data_mode != 0,1,2) in" + fileName); if (map_dim[2] != 1) { require(strcmp(mapStamp, "MAP ") == 0, funcName + ": cannot detect the 'MAP' string in " + fileName); } // check symmetry validity size_t fileSize, dataOffset, nelement = (size_t) map_dim[0] * (size_t) map_dim[1] * (size_t) map_dim[2]; fileHandle.seekg(0, std::ios::end); fileSize = fileHandle.tellg(); switch (data_mode) { case 0: // int8 dataOffset = fileSize - 1 * nelement; break; case 1: // int16 dataOffset = fileSize - 2 * nelement; break; case 2: // float32 dataOffset = fileSize - 4 * nelement; break; case 6: // uint16 dataOffset = fileSize - 2 * nelement; break; default: ERROR(funcName, "unsupported data mode in reading " + fileName); } if ((int) dataOffset != (CCP4_HEADER_SIZE + sym_byte)) { if (dataOffset < CCP4_HEADER_SIZE) { ERROR(funcName, "file " + fileName + " has size smaller than expected"); } else if (dataOffset == CCP4_HEADER_SIZE) { ERROR(funcName, "the symmetry record in " + fileName + " is bogus"); } else { ERROR(funcName, "file " + fileName + " has size larger than expected"); } } // save header information header.file_name = fileName; header.data_mode = data_mode; header.spacegroup = spacegroup; header.sym_byte = sym_byte; header.cell_dim[0] = cell_dim[0]; header.cell_dim[1] = cell_dim[1]; header.cell_dim[2] = cell_dim[2]; header.cell_angle[0] = cell_angle[0]; header.cell_angle[1] = cell_angle[1]; header.cell_angle[2] = cell_angle[2]; header.map_dim[0] = map_dim[0]; header.map_dim[1] = map_dim[1]; header.map_dim[2] = map_dim[2]; header.origin[0] = origin[0]; header.origin[1] = origin[1]; header.origin[2] = origin[2]; header.cell_grid[0] = cell_grid[0]; header.cell_grid[1] = cell_grid[1]; header.cell_grid[2] = cell_grid[2]; header.axes_order[0] = axes_order[0]; header.axes_order[1] = axes_order[1]; header.axes_order[2] = axes_order[2]; header.min = density_min; header.max = density_max; header.mean = density_mean; fileHandle.close(); }
void cMRC<T>::write(const cData3<T>& object, const std::string& fileName, cMapHeader* header) { const std::string funcName("void cMRC::write(const cData3<T>& object, " "const std::string& fileName, cMapHeader* header)"); require(object.getAddrData() != NULL, funcName + "writing an empty object"); checkExtension(fileName); std::ofstream fileHandle; fileHandle.open(fileName.c_str(), std::ofstream::binary); assure(fileHandle, fileName.c_str()); int map_dim[3], data_mode, origin[3], cell_grid[3], axes_order[3]; float cell_dim[3], cell_angle[3]; float density_min, density_max, density_mean; int spacegroup, sym_byte = 0; char mapStamp[] = "MAP "; // write map header if (header) { if (header->map_dim[0] == (int) object.getNrow() && header->map_dim[1] == (int) object.getNcol() && header->map_dim[2] == (int) object.getNsec()) { data_mode = header->data_mode; spacegroup = header->spacegroup; cell_dim[0] = header->cell_dim[0]; cell_dim[1] = header->cell_dim[1]; cell_dim[2] = header->cell_dim[2]; cell_angle[0] = header->cell_angle[0]; cell_angle[1] = header->cell_angle[1]; cell_angle[2] = header->cell_angle[2]; map_dim[0] = header->map_dim[0]; map_dim[1] = header->map_dim[1]; map_dim[2] = header->map_dim[2]; origin[0] = header->origin[0]; origin[1] = header->origin[1]; origin[2] = header->origin[2]; cell_grid[0] = header->cell_grid[0]; cell_grid[1] = header->cell_grid[1]; cell_grid[2] = header->cell_grid[2]; axes_order[0] = header->axes_order[0]; axes_order[1] = header->axes_order[1]; axes_order[2] = header->axes_order[2]; } else { ERROR(funcName, "header information does not match in writing " + fileName); } } else { map_dim[0] = (int) object.getNrow(); map_dim[1] = (int) object.getNcol(); map_dim[2] = (int) object.getNsec(); data_mode = 2; spacegroup = 0; cell_dim[0] = (float) map_dim[0]; cell_dim[1] = (float) map_dim[1]; cell_dim[2] = (float) map_dim[2]; cell_angle[0] = 90; cell_angle[1] = 90; cell_angle[2] = 90; origin[0] = 0; origin[1] = 0; origin[2] = 0; cell_grid[0] = map_dim[0]; cell_grid[1] = map_dim[1]; cell_grid[2] = map_dim[2]; axes_order[0] = 1; axes_order[1] = 2; axes_order[2] = 3; } fileHandle.write((char*) map_dim, 3*sizeof(int)); // NX, NY, NZ fileHandle.write((char*) &data_mode, sizeof(int)); // MODE fileHandle.write((char*) origin, 3*sizeof(int)); // NXSTART, NYSTART, NZSTART fileHandle.write((char*) cell_grid, 3*sizeof(int)); // MX, MY, MZ fileHandle.write((char*) cell_dim, 3*sizeof(float)); // CELLA fileHandle.write((char*) cell_angle, 3*sizeof(float)); // CELLB fileHandle.write((char*) axes_order, 3*sizeof(int)); // MAPC, MAPR, MAPS fileHandle.write((char*) &density_min, sizeof(float)); // DMIN fileHandle.write((char*) &density_max, sizeof(float)); // DMAX fileHandle.write((char*) &density_mean, sizeof(float)); // DMEAN fileHandle.write((char*) &spacegroup, sizeof(int)); // ISPG fileHandle.write((char*) &sym_byte, sizeof(int)); // NSYMBT fileHandle.seekp(208, std::ios::beg); fileHandle.write((char*) mapStamp, 4*sizeof(char)); // MAP // write map data, assume no symmetry information fileHandle.seekp(CCP4_HEADER_SIZE, std::ios::beg); unsigned char* bufferData = NULL; size_t bufferLength, nelement = (size_t) (map_dim[0]*map_dim[1]*map_dim[2]); switch (data_mode) { case 0: // int8 bufferLength = 1 * nelement; break; case 1: // int16 bufferLength = 2 * nelement; break; case 2: // float32 bufferLength = 4 * nelement; break; case 6: // uint16 bufferLength = 2 * nelement; break; default: ERROR(funcName, "unsupported data mode in reading " + fileName); } array_new(bufferData, bufferLength); switch (data_mode) { case 0: // int8 array_index_row2col(object.getAddrData(), (int8_t*) bufferData, object.getNrow(), object.getNcol(), object.getNsec()); break; case 1: // int16 array_index_row2col(object.getAddrData(), (int16_t*) bufferData, object.getNrow(), object.getNcol(), object.getNsec()); break; case 2: // float32 array_index_row2col(object.getAddrData(), (float*) bufferData, object.getNrow(), object.getNcol(), object.getNsec()); break; case 6: // uint16 array_index_row2col(object.getAddrData(), (uint16_t*) bufferData, object.getNrow(), object.getNcol(), object.getNsec()); break; default: ERROR(funcName, "unsupported data mode in writing " + fileName); } fileHandle.write((char*) bufferData, bufferLength); array_delete(bufferData); fileHandle.close(); }
void cMRC<T>::readData(const std::string& fileName, cData3<T>& object, cMapHeader& header) { const std::string funcName("void cMRC::readData(const std::string& fileName, " "cData3<T>& object, cMapHeader& header)"); checkExtension(fileName); std::ifstream fileHandle; fileHandle.open(fileName.c_str(), std::ifstream::binary); assure(fileHandle, fileName.c_str()); // allocate new memory object.memReAlloc(cVector3<size_t>((size_t) header.map_dim[0], (size_t) header.map_dim[1], (size_t) header.map_dim[2])); // seek to data starting point fileHandle.seekg(CCP4_HEADER_SIZE + header.sym_byte, std::ios::beg); unsigned char* bufferData = NULL; size_t bufferLength = (size_t) std::pow(2,header.data_mode) * header.getNelement(); array_new(bufferData, bufferLength); fileHandle.read((char*) bufferData, bufferLength); switch (header.data_mode) { case 0: // int8 array_index_col2row((int8_t*) bufferData, object.getAddrData(), object.getNrow(), object.getNcol(), object.getNsec()); break; case 1: // int16 if (header.edian_swap) { swap2_aligned(bufferData, header.getNelement()); } array_index_col2row((int16_t*) bufferData, object.getAddrData(), object.getNrow(), object.getNcol(), object.getNsec()); break; case 2: // float32 if (header.edian_swap) { swap4_aligned(bufferData, header.getNelement()); } array_index_col2row((float*) bufferData, object.getAddrData(), object.getNrow(), object.getNcol(), object.getNsec()); break; case 6: // uint16 if (header.edian_swap) { swap2_aligned(bufferData, header.getNelement()); } array_index_col2row((uint16_t*) bufferData, object.getAddrData(), object.getNrow(), object.getNcol(), object.getNsec()); break; default: ERROR(funcName, "unsupported data mode in reading " + fileName); } array_delete(bufferData); fileHandle.close(); }
std::auto_ptr<AbstractTextFileReader> openIndexFile(const std::string& fileName) { if (checkExtension(fileName, ".gz")) return createTextFileReader(TextFileGZip, fileName); return createTextFileReader(TextFileStd, fileName); }
int fileio_load_archive(const char *filename, unsigned char **dataout, int *datasize, int *dataoffset, const char *filetoload, char *outname) { FILE *f; unsigned char idbuf[4]; int filesFound = 0; std::vector<char *> filelist; // list of files we can load in this archive // default case: outname is filename if (outname) { strcpy(outname, filename); } f = fopen(filename, "rb"); if (!f) { return 0; // no good } fread(idbuf, 4, 1, f); fclose(f); // printf("ID bytes %c %c %x %x\n", idbuf[0], idbuf[1], idbuf[2], idbuf[3]); // Handle all archives with common libarchive code if ((idbuf[0] == 'P') && (idbuf[1] == 'K') && (idbuf[2] == 0x03) && (idbuf[3] == 0x04) || // zip ((idbuf[0] == '7') && (idbuf[1] == 'z') && (idbuf[2] == 0xbc) && (idbuf[3] == 0xaf)) || // 7zip ((idbuf[0] == 0xfd) && (idbuf[1] == 0x37) && (idbuf[2] == 0x7a) && (idbuf[3] == 0x58)) || // txz ((idbuf[0] == 0x1f) && (idbuf[1] == 0x8b) && (idbuf[2] == 0x08) && (idbuf[3] == 0x00)) || // tgz ((idbuf[0] == 0x42) && (idbuf[1] == 0x5a) && (idbuf[2] == 0x68) && (idbuf[3] == 0x39)) // tbz ) { a = archive_read_new(); archive_read_support_filter_all(a); archive_read_support_format_all(a); r = archive_read_open_filename(a, filename, 10240); int64_t entry_size; if (r != ARCHIVE_OK) { print_message("Archive failed to open."); } while (archive_read_next_header(a, &entry) == ARCHIVE_OK) { const char *currentFile = archive_entry_pathname(entry); unsigned char *fileContents; entry_size = archive_entry_size(entry); fileContents = (unsigned char *)malloc(entry_size); if (filetoload != NULL) { if (!strcmp(currentFile, filetoload)) { archive_read_data(a, fileContents, entry_size); archive_read_data_skip(a); r = archive_read_free(a); *datasize = entry_size; *dataout = fileContents; *dataoffset = 0; return 1; } } else { if (checkExtension(currentFile)) { char *tmpstr; tmpstr = (char *)malloc(strlen(currentFile)+1); strcpy(tmpstr, currentFile); // add to the file list filelist.push_back(tmpstr); filesFound++; } } } } else if ((idbuf[0] == 'R') && (idbuf[1] == 'a') && (idbuf[2] == 'r') && (idbuf[3] == '!')) { // it's rar print_message("Rar files are not supported."); } // if we found any files and weren't forced to load them, handle accordingly if (filesFound) { // only 1 file found, just run it if (filesFound == 1) { char fname[512]; strcpy(fname, filelist[0]); free(filelist[0]); filelist.clear(); strcpy(outname, fname); return fileio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL); } else // multiple files we can handle found, give the user a choice { int sel; char fname[512]; GtkWidget *archselect = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (archselect), "Pick game in archive"); gtk_window_set_modal(GTK_WINDOW (archselect), TRUE); GtkWidget *archbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(archselect), archbox); gtk_widget_show(archbox); GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(archbox), scrolledwindow, TRUE, TRUE, 0); gtk_widget_set_size_request(scrolledwindow, 340, 340); gtk_widget_show(scrolledwindow); GtkWidget *buttonbox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL); gtk_box_pack_start(GTK_BOX(archbox), buttonbox, FALSE, TRUE, 0); gtk_widget_show(buttonbox); GtkWidget *archtree = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER (scrolledwindow), archtree); gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (archtree), FALSE); g_signal_connect(G_OBJECT(archtree), "button_press_event", G_CALLBACK(check_list_double), NULL); gtk_widget_show(archtree); // set up our tree store treestore = gtk_tree_store_new(1, G_TYPE_STRING); // attach the store to the tree gtk_tree_view_set_model(GTK_TREE_VIEW(archtree), GTK_TREE_MODEL(treestore)); for (int fn = 0; fn < filelist.size(); fn++) { gtk_tree_store_insert(treestore, &treeiters[fn], NULL, 999999); gtk_tree_store_set(treestore, &treeiters[fn], 0, filelist[fn], -1); } // create a cell renderer using the stock text one renderer = gtk_cell_renderer_text_new(); // create a display column using the renderer column = gtk_tree_view_column_new_with_attributes ("NES file", renderer, "text", 0, NULL); // add the display column and renderer to the tree view gtk_tree_view_append_column(GTK_TREE_VIEW (archtree), column); GtkWidget *archcancel = gtk_widget_new(GTK_TYPE_BUTTON, "label", GTK_STOCK_CANCEL, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_button_set_use_stock(GTK_BUTTON(archcancel), TRUE); gtk_box_pack_start(GTK_BOX(buttonbox), archcancel, FALSE, FALSE, 0); gtk_widget_show(archcancel); GtkWidget *archok = gtk_widget_new(GTK_TYPE_BUTTON, "label", GTK_STOCK_OK, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_button_set_use_stock(GTK_BUTTON(archok), TRUE); gtk_box_pack_start(GTK_BOX(buttonbox), archok, FALSE, FALSE, 0); gtk_widget_show(archok); // get the selection object too selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(archtree)); g_signal_connect(G_OBJECT(archcancel), "clicked", G_CALLBACK(on_archcancel_clicked), NULL); g_signal_connect(G_OBJECT(archok), "clicked", G_CALLBACK(on_archok_clicked), NULL); g_signal_connect(G_OBJECT(archselect), "destroy", G_CALLBACK(on_archselect_destroyed), NULL); gtk_widget_show(archselect); run_picker = true; cancelled = false; while (run_picker) { gtk_main_iteration_do(TRUE); } sel = find_current_selection(); gtk_widget_destroy(archselect); // was something picked? if ((sel != -1) && (!cancelled)) { strcpy(fname, filelist[sel]); } // free all the temp filenames for (int fn = 0; fn < filelist.size(); fn++) { free(filelist[fn]); } // and wipe the vector filelist.clear(); if ((sel != -1) && (!cancelled)) { if (outname) { strcpy(outname, fname); } return fileio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL); } } } return 0; }
void RunBenchmark( cl::Device& dev, cl::Context& ctx, cl::CommandQueue& queue, ResultDatabase& resultDB, OptionParser& op ) { #if defined(PARALLEL) int cwrank; #endif // defined(PARALLEL) // single precision DoTest<float>( "SP_Sten2D", dev, ctx, queue, resultDB, op, "-DSINGLE_PRECISION" ); // double precision - might not be supported if( checkExtension( dev, "cl_khr_fp64" )) { #if defined(PARALLEL) MPI_Comm_rank( MPI_COMM_WORLD, &cwrank ); if( cwrank == 0 ) { #endif // defined(PARALLEL) std::cout << "\nDP supported\n"; #if defined(PARALLEL) } #endif // defined(PARALLEL) DoTest<double>( "DP_Sten2D", dev, ctx, queue, resultDB, op, "-DK_DOUBLE_PRECISION" ); } else if( checkExtension( dev, "cl_amd_fp64" )) { #if defined(PARALLEL) MPI_Comm_rank( MPI_COMM_WORLD, &cwrank ); if( cwrank == 0 ) { #endif // defined(PARALLEL) std::cout << "\nDP supported\n"; #if defined(PARALLEL) } #endif // defined(PARALLEL) DoTest<double>( "DP_Sten2D", dev, ctx, queue, resultDB, op, "-DAMD_DOUBLE_PRECISION" ); } else { #if defined(PARALLEL) MPI_Comm_rank( MPI_COMM_WORLD, &cwrank ); if( cwrank == 0 ) { #endif // defined(PARALLEL) std::cout << "\nDP not supported\n"; #if defined(PARALLEL) } #endif // defined(PARALLEL) // resultDB requires an entry for every possible result int nPasses = (int)op.getOptionInt( "passes" ); for( unsigned int p = 0; p < nPasses; p++ ) { resultDB.AddResult( (const char*)"DP_Sten2D", "N/A", "GFLOPS", FLT_MAX ); } } std::cout << '\n' << std::endl; }
int auxio_load_archive(const char *filename, unsigned char **dataout, int *datasize, int *dataoffset, const char *filetoload, char *outname) { FILE *f; unsigned char idbuf[4]; int filesFound = 0; std::vector<char *> filelist; // list of files we can load in this archive // default case: outname is filename if (outname) { strcpy(outname, filename); } f = fopen(filename, "rb"); if (!f) { return 0; // no good } fread(idbuf, 4, 1, f); fclose(f); // printf("ID bytes %c %c %x %x\n", idbuf[0], idbuf[1], idbuf[2], idbuf[3]); if ((idbuf[0] == 'P') && (idbuf[1] == 'K') && (idbuf[2] == 0x03) && (idbuf[3] == 0x04)) { // it's zip unzFile zipArchive; char file_name[1024]; unz_file_info info; int nlen; int ret = 0; zipArchive = unzOpen(filename); if (!zipArchive) { return 0; } unzGoToFirstFile(zipArchive); for (;;) { if (unzGetCurrentFileInfo(zipArchive, &info, file_name, 1024, NULL, 0, NULL, 0) == UNZ_OK) { if (filetoload != NULL) { if (!strcasecmp(filetoload, file_name)) { int length; unsigned char *buffer; unzOpenCurrentFile(zipArchive); length = info.uncompressed_size; buffer = (unsigned char *)malloc(length); ret = unzReadCurrentFile(zipArchive, buffer, length); if (ret != length) { free(buffer); return 0; } unzCloseCurrentFile(zipArchive); unzClose(zipArchive); *datasize = length; *dataout = buffer; *dataoffset = 0; return 1; } } else { if (checkExtension(file_name)) { char *tmpstr; tmpstr = (char *)malloc(strlen(file_name)+1); strcpy(tmpstr, file_name); // add to the file list filelist.push_back(tmpstr); filesFound++; } } } else { break; } ret = unzGoToNextFile(zipArchive); if (ret == UNZ_END_OF_LIST_OF_FILE) { break; } if (ret != UNZ_OK) { unzClose(zipArchive); return 0; } } unzClose(zipArchive); } else if ((idbuf[0] == '7') && (idbuf[1] == 'z') && (idbuf[2] == 0xbc) && (idbuf[3] == 0xaf)) { // it's 7zip CFileInStream archiveStream; SRes res; CSzArEx db; /* 7z archive database structure */ ISzAlloc allocImp; /* memory functions for main pool */ ISzAlloc allocTempImp; /* memory functions for temporary pool */ archiveStream.File = fopen(filename, "rb"); if (!archiveStream.File) { return 0; } archiveStream.InStream.Read = SzFileReadImp; archiveStream.InStream.Seek = SzFileSeekImp; allocImp.Alloc = SzAlloc; allocImp.Free = SzFree; allocTempImp.Alloc = SzAllocTemp; allocTempImp.Free = SzFreeTemp; // init 7zip internals CrcGenerateTable(); SzArEx_Init(&db); res = SzArEx_Open(&db, &archiveStream.InStream, &allocImp, &allocTempImp); if (res == SZ_OK) { int i; for (i = 0; i < db.db.NumFiles; i++) { CSzFileItem *item = db.db.Files + i; if (!item->IsDirectory) { if (filetoload != NULL) { if (!strcasecmp(filetoload, item->Name)) { UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */ Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */ size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */ size_t offset; size_t outSizeProcessed; res = SzAr_Extract(&db, &archiveStream.InStream, i, &blockIndex, &outBuffer, &outBufferSize, &offset, &outSizeProcessed, &allocImp, &allocTempImp); if (res == SZ_OK) { SzArEx_Free(&db, &allocImp); fclose(archiveStream.File); *datasize = (int)outBufferSize; *dataout = (unsigned char *)outBuffer; *dataoffset = (int)offset; return 1; } else { std::cout << "Error extracting 7zip!\n"; } } } if (checkExtension(item->Name)) { char *tmpstr; tmpstr = (char *)malloc(strlen(item->Name)+1); strcpy(tmpstr, item->Name); // add to the file list filelist.push_back(tmpstr); filesFound++; } } } SzArEx_Free(&db, &allocImp); fclose(archiveStream.File); } } else if ((idbuf[0] == 'R') && (idbuf[1] == 'a') && (idbuf[2] == 'r') && (idbuf[3] == '!')) { // it's rar } // if we found any files and weren't forced to load them, handle accordingly if (filesFound) { // only 1 file found, just run it if (filesFound == 1) { char fname[512]; strcpy(fname, filelist[0]); free(filelist[0]); filelist.clear(); strcpy(outname, fname); return auxio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL); } else // multiple files we can handle found, give the user a choice { int sel; char fname[512]; filepicker = create_archselect(); tree = lookup_widget(filepicker, "archtree"); gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (tree), FALSE); g_signal_connect(G_OBJECT(tree), "button_press_event", G_CALLBACK(check_list_double), NULL); // set up our tree store treestore = gtk_tree_store_new(1, G_TYPE_STRING); // attach the store to the tree gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(treestore)); // create a cell renderer using the stock text one renderer = gtk_cell_renderer_text_new(); // create a display column using the renderer column = gtk_tree_view_column_new_with_attributes ("NES file", renderer, "text", 0, NULL); // add the display column and renderer to the tree view gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); // get the selection object too selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); // add the filenames for (int fn = 0; fn < filelist.size(); fn++) { gtk_tree_store_insert(treestore, &treeiters[fn], NULL, 999999); gtk_tree_store_set(treestore, &treeiters[fn], 0, filelist[fn], -1); } gtk_widget_show(filepicker); run_picker = true; cancelled = false; while (run_picker) { gtk_main_iteration_do(FALSE); } sel = find_current_selection(); gtk_widget_destroy(filepicker); // was something picked? if ((sel != -1) && (!cancelled)) { strcpy(fname, filelist[sel]); } // free all the temp filenames for (int fn = 0; fn < filelist.size(); fn++) { free(filelist[fn]); } // and wipe the vector filelist.clear(); if ((sel != -1) && (!cancelled)) { if (outname) { strcpy(outname, fname); } return auxio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL); } } } return 0; }
LRESULT APIENTRY WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) { case WM_CREATE: /* ** Set up for OpenGL rendering. Bind the rendering context to ** the same device context that the palette will be selected into. */ hDC = GetDC(hWnd); setupPixelFormat(hDC); setupPalette(hDC); hGLRC = wglCreateContext(hDC); wglMakeCurrent(hDC, hGLRC); if (!checkExtension("SGI_index_texture")) { char message[1024]; sprintf(message, "SGI_index_texture is required by this application\n" "but is not supported by the current OpenGL renderer.\n\n" "Vendor: %s\nRenderer: %s\nVersion: %s", glGetString(GL_VENDOR), glGetString(GL_RENDERER), glGetString(GL_VERSION)); wglMakeCurrent(NULL, NULL); wglDeleteContext(hGLRC); hGLRC = NULL; MessageBox(hWnd, message, "OpenGL Extension Required", MB_ICONERROR | MB_OK); exit(1); } init(); idleFunc = doRedraw; return 0; case WM_DESTROY: /* ** Finish OpenGL rendering. */ idleFunc = NULL; if (hGLRC) { wglMakeCurrent(NULL, NULL); wglDeleteContext(hGLRC); } ReleaseDC(hWnd, hDC); PostQuitMessage(0); return 0; case WM_SIZE: if (hGLRC) { winWidth = (int) LOWORD(lParam); winHeight = (int) HIWORD(lParam); resize(); return 0; } case WM_PALETTECHANGED: /* ** Update palette mapping if this *is not* the active window. */ if (hGLRC && hPalette && (HWND) wParam != hWnd) { UnrealizeObject(hPalette); SelectPalette(hDC, hPalette, FALSE); RealizePalette(hDC); redraw(); return 0; } break; case WM_QUERYNEWPALETTE: /* ** Update palette mapping if this *is* the active window. */ if (hGLRC && hPalette) { UnrealizeObject(hPalette); SelectPalette(hDC, hPalette, FALSE); RealizePalette(hDC); redraw(); return TRUE; } break; case WM_PAINT: /* ** Update the window. Don't use the device context returned by ** BeginPaint as it won't have the right palette selected into it. */ if (hGLRC) { PAINTSTRUCT ps; BeginPaint(hWnd, &ps); redraw(); EndPaint(hWnd, &ps); return 0; } break; case WM_CHAR: switch ((int)wParam) { case VK_ESCAPE: DestroyWindow(hWnd); return 0; default: break; } break; default: break; } /* Deal with any unprocessed messages */ return DefWindowProc(hWnd, message, wParam, lParam); }
void cESBTL::pdbPrintAtom(const std::string& fileIn, const std::string& atomName) { checkExtension(fileIn); ESBTL::PDB_line_selector pdbSelector; std::vector<ESBTL::Default_system> pdbSystems; ESBTL::All_atom_system_builder<ESBTL::Default_system> pdbBuilder(pdbSystems, pdbSelector.max_nb_systems()); require(ESBTL::read_a_pdb_file(fileIn, pdbSelector, pdbBuilder, Occupancy_policy_all()), "cannot read PDB file"); require(!pdbSystems.empty(), "No PDB system"); require( pdbSystems.size() == 1, "More than one PDB system: pdbSystems.size() = " + num2str(pdbSystems.size())); require(!pdbSystems[0].has_no_model(), "No model in 1st PDB system"); require( pdbSystems[0].number_of_models() == 1, "More than one model in 1st PDB system: pdbSystems[0].number_of_models() = " + num2str(pdbSystems[0].number_of_models())); // iterate over all models for (ESBTL::Default_system::Models_iterator iterModel = pdbSystems[0].models_begin(); iterModel != pdbSystems[0].models_end(); iterModel++) { const ESBTL::Default_system::Model& model = *iterModel; //std::cout << "Model " << model.model_number() << std::endl; for (ESBTL::Default_system::Model::Chains_const_iterator iterChain = model.chains_begin(); iterChain != model.chains_end(); iterChain++) { const ESBTL::Default_system::Chain& chain = *iterChain; //std::cout << "Model " << model.model_number() // << ", chain " << chain.chain_identifier() << std::endl; for (ESBTL::Default_system::Chain::Residues_const_iterator iterResidue = chain.residues_begin(); iterResidue != chain.residues_end(); iterResidue++) { const ESBTL::Default_system::Residue& residue = *iterResidue; //std::cout << "Model " << model.model_number() // << ", chain " << chain.chain_identifier() // << ", residue " << residue.residue_name() << std::endl; for (ESBTL::Default_system::Residue::Atoms_const_iterator iterAtom = residue.atoms_begin(); iterAtom != residue.atoms_end(); iterAtom++) { if (atomName == "" || iterAtom->atom_name() == atomName) { std::cout << "Model " << model.model_number() << ", chain " << chain.chain_identifier() << ", residue " << residue.residue_name() << ", atom " << iterAtom->atom_name(); std::cout << std::setprecision(4) << std::fixed << std::setw(7) << iterAtom->atom_serial_number() << std::setw(5) << iterAtom->charge() << std::setw(4) << iterAtom->element() << std::setw(11) << iterAtom->x() << std::setw(11) << iterAtom->y() << std::setw(11) << iterAtom->z(); std::cout << std::endl; } } } } } }
void cCCP4<T>::write(const cData3<T>& object, const std::string& fileName, cMapHeader* header) { const std::string funcName("void cCCP4::write(const cData3<T>& object, " "const std::string& fileName, cMapHeader* header)"); require(object.getAddrData() != NULL, funcName + ":writing an empty object"); checkExtension(fileName); CMap_io::CMMFile *fileHandle = (CMap_io::CMMFile *) CMap_io::ccp4_cmap_open(fileName.c_str(), O_WRONLY); require(fileHandle, funcName + ": could not open CCP4 file " + fileName); // write map header if (header) { if (header->map_dim[0] == (int) object.getNrow() && header->map_dim[1] == (int) object.getNcol() && header->map_dim[2] == (int) object.getNsec()) { fileHandle->data_mode = header->data_mode; fileHandle->spacegroup = header->spacegroup; fileHandle->cell[0] = header->cell_dim[0]; fileHandle->cell[1] = header->cell_dim[1]; fileHandle->cell[2] = header->cell_dim[2]; fileHandle->cell[3] = header->cell_angle[0]; fileHandle->cell[4] = header->cell_angle[1]; fileHandle->cell[5] = header->cell_angle[2]; fileHandle->map_dim[0] = header->map_dim[0]; fileHandle->map_dim[1] = header->map_dim[1]; fileHandle->map_dim[2] = header->map_dim[2]; fileHandle->origin[0] = header->origin[0]; fileHandle->origin[1] = header->origin[1]; fileHandle->origin[2] = header->origin[2]; fileHandle->cell_grid[0] = header->cell_grid[0]; fileHandle->cell_grid[1] = header->cell_grid[1]; fileHandle->cell_grid[2] = header->cell_grid[2]; fileHandle->axes_order[0] = header->axes_order[0]; fileHandle->axes_order[1] = header->axes_order[1]; fileHandle->axes_order[2] = header->axes_order[2]; } else { ERROR(funcName, "header information does not match in writing " + fileName); } } else { fileHandle->map_dim[0] = (int) object.getNrow(); fileHandle->map_dim[1] = (int) object.getNcol(); fileHandle->map_dim[2] = (int) object.getNsec(); fileHandle->data_mode = 2; fileHandle->spacegroup = 0; fileHandle->cell[0] = (float) fileHandle->map_dim[0]; fileHandle->cell[1] = (float) fileHandle->map_dim[1]; fileHandle->cell[2] = (float) fileHandle->map_dim[2]; fileHandle->cell[3] = 90; fileHandle->cell[4] = 90; fileHandle->cell[5] = 90; fileHandle->origin[0] = 0; fileHandle->origin[1] = 0; fileHandle->origin[2] = 0; fileHandle->cell_grid[0] = fileHandle->map_dim[0]; fileHandle->cell_grid[1] = fileHandle->map_dim[1]; fileHandle->cell_grid[2] = fileHandle->map_dim[2]; fileHandle->axes_order[0] = 1; fileHandle->axes_order[1] = 2; fileHandle->axes_order[2] = 3; } // write map data, assume no symmetry information ccp4_cmap_seek_data(fileHandle, CCP4_HEADER_SIZE / 4, SEEK_SET); int8_t *dataInt8 = NULL; int16_t *dataInt16 = NULL; float *dataFloat = NULL; switch (fileHandle->data_mode) { case 0: // int8 array_new(dataInt8, object.getNelement()); array_index_row2col(object.getAddrData(), dataInt8, object.getNrow(), object.getNcol(), object.getNsec()); ccp4_cmap_write_data(fileHandle, (void *) dataInt8, (int) object.getNelement()); array_delete(dataInt8); case 1: // int16 array_new(dataInt16, object.getNelement()); array_index_row2col(object.getAddrData(), dataInt16, object.getNrow(), object.getNcol(), object.getNsec()); ccp4_cmap_write_data(fileHandle, (void *) dataInt16, (int) object.getNelement()); array_delete(dataInt16); case 2: // float32 array_new(dataFloat, object.getNelement()); array_index_row2col(object.getAddrData(), dataFloat, object.getNrow(), object.getNcol(), object.getNsec()); ccp4_cmap_write_data(fileHandle, (void *) dataFloat, (int) object.getNelement()); array_delete(dataFloat); break; default: ERROR(funcName, "unsupported data mode in writing " + fileName); } ccp4_cmap_close(fileHandle); }
/*do_something - processes requests from client*/ void do_something(int client) { int len; struct stat statbuf; int fileType; printf("Connected\n"); if ((len = recv(client, buffer, MAXBUF, 0)) > 0 ) { FILE* ClientFP = fdopen(client, "w"); if ( ClientFP == NULL ) perror("fpopen"); else { char Req[MAXPATH]; char *args; int hasArgs=0; sscanf(buffer, "GET %s HTTP", Req); if (strpbrk(Req, "?") != 0) { char *Req1; printf("has args?\n"); hasArgs=1; Req1 = strtok(Req, "?"); args = strtok(NULL, "?"); printf("args: \"%s\"\n", args); } printf("Request: \"%s\"\n", Req); if (lstat(Req, &statbuf) < 0) { write(client,"HTTP/1.0 404 Not Found\n", 23); write(client,"Content-type: text/html\n", 24); write(client,"\n",1); sendFileOverSocket(client,"bad.html"); printf("Stat error.\n"); } else if (S_ISDIR(statbuf.st_mode)) { printf("Is Dir\n"); fprintf(ClientFP,"HTTP/1.0 200 OK\n"); fprintf(ClientFP,"Content-type: text/html\n"); fprintf(ClientFP,"\n"); DirListing(ClientFP, Req); } else { printf("checking file type\n"); fileType = checkExtension(Req); printf("file type is %d\n", fileType); if (fileType == 1) { printf("Is html file.\n"); write(client,"HTTP/1.0 200 OK\n",16 ); write(client,"Content-type: text/html\n", 25); write(client,"\n",1); sendFileOverSocket(client,Req); } else if (fileType == 2) { printf("Is jpeg file.\n"); write(client,"HTTP/1.0 200 OK\n",16 ); write(client,"Content-type: image/jpeg\n", 25); write(client,"\n",1); sendFileOverSocket(client,Req); } else if (fileType == 3) { printf("Is gif file.\n"); write(client,"HTTP/1.0 200 OK\n",16 ); write(client,"Content-type: image/gif\n", 24); write(client,"\n",1); sendFileOverSocket(client,Req); } else if (fileType == 4) { printf("is cgi file.\n"); dup2(client,1); write(client,"HTTP/1.0 200 OK\n",16 ); if(hasArgs==0){ printf("Executing with no args"); execlp(Req,Req,NULL); } else{ execlp(Req,Req,args,NULL); } } else { printf("Incorrect file.\n"); write(client,"HTTP/1.0 501 Not Implemented\n",23); write(client,"Content-type: text/plain\n", 25); write(client,"\n",1); write(client,"Viewing this file type has not been implemented",47); } } printf("about to close FP"); fclose(ClientFP); } } }
bool createARB(HDC hDC) { bool required = profile.api != glfeatures::API_GL || profile.versionGreaterOrEqual(3, 1); // We need to create context through WGL_ARB_create_context. This // implies binding a temporary context to get the extensions strings // and function pointers. // This function is only called inside makeCurrent, so we don't need // to save and restore the previous current context/drawable. BOOL bRet = wglMakeCurrent(hDC, hglrc); if (!bRet) { std::cerr << "error: wglMakeCurrent failed\n"; exit(1); } pfnWglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB"); if (!pfnWglGetExtensionsStringARB) { if (required) { std::cerr << "error: WGL_ARB_extensions_string not supported\n"; exit(1); } else { return false; } } const char * extensionsString = pfnWglGetExtensionsStringARB(hDC); assert(extensionsString); if (checkExtension("WGL_ARB_pbuffer", extensionsString)) { has_WGL_ARB_pbuffer = true; WGL_PROC(PFNWGLCREATEPBUFFERARBPROC, pfnWglCreatePbufferARB, "wglCreatePbufferARB"); WGL_PROC(PFNWGLGETPBUFFERDCARBPROC, pfnWglGetPbufferDCARB, "wglGetPbufferDCARB"); WGL_PROC(PFNWGLCHOOSEPIXELFORMATARBPROC, pfnWglChoosePixelFormatARB, "wglChoosePixelFormatARB"); WGL_PROC(PFNWGLDESTROYPBUFFERARBPROC, pfnWglDestroyPbufferARB, "wglDestroyPbufferARB"); WGL_PROC(PFNWGLRELEASEPBUFFERDCARBPROC, pfnWglReleasePbufferDCARB, "wglReleasePbufferDCARB"); } if (checkExtension("WGL_ARB_render_texture", extensionsString)) { assert(has_WGL_ARB_pbuffer); has_WGL_ARB_render_texture = true; WGL_PROC(PFNWGLBINDTEXIMAGEARBPROC, pfnWglBindTexImageARB, "wglBindTexImageARB"); WGL_PROC(PFNWGLRELEASETEXIMAGEARBPROC, pfnWglReleaseTexImageARB, "wglReleaseTexImageARB"); WGL_PROC(PFNWGLSETPBUFFERATTRIBARBPROC, pfnWglSetPbufferAttribARB, "wglSetPbufferAttribARB"); } if (!checkExtension("WGL_ARB_create_context", extensionsString)) { if (required) { std::cerr << "error: WGL_ARB_create_context not supported\n"; exit(1); } else { return false; } } PFNWGLCREATECONTEXTATTRIBSARBPROC pfnWglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) wglGetProcAddress("wglCreateContextAttribsARB"); if (!pfnWglCreateContextAttribsARB) { if (required) { std::cerr << "error: failed to get pointer to wglCreateContextAttribsARB\n"; exit(1); } else { return false; } } wglMakeCurrent(hDC, NULL); Attributes<int> attribs; int contextFlags = 0; if (profile.api == glfeatures::API_GL) { attribs.add(WGL_CONTEXT_MAJOR_VERSION_ARB, profile.major); attribs.add(WGL_CONTEXT_MINOR_VERSION_ARB, profile.minor); if (profile.versionGreaterOrEqual(3, 2)) { if (!checkExtension("WGL_ARB_create_context_profile", extensionsString)) { assert(required); std::cerr << "error: WGL_ARB_create_context_profile not supported\n"; exit(1); } int profileMask = profile.core ? WGL_CONTEXT_CORE_PROFILE_BIT_ARB : WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; attribs.add(WGL_CONTEXT_PROFILE_MASK_ARB, profileMask); if (profile.forwardCompatible) { contextFlags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; } } } else if (profile.api == glfeatures::API_GLES) { if (checkExtension("WGL_EXT_create_context_es_profile", extensionsString)) { attribs.add(WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_ES_PROFILE_BIT_EXT); attribs.add(WGL_CONTEXT_MAJOR_VERSION_ARB, profile.major); attribs.add(WGL_CONTEXT_MINOR_VERSION_ARB, profile.minor); } else if (profile.major != 2) { std::cerr << "warning: OpenGL ES " << profile.major << " requested but WGL_EXT_create_context_es_profile not supported\n"; } else if (checkExtension("WGL_EXT_create_context_es2_profile", extensionsString)) { assert(profile.major == 2); attribs.add(WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_ES2_PROFILE_BIT_EXT); attribs.add(WGL_CONTEXT_MAJOR_VERSION_ARB, profile.major); attribs.add(WGL_CONTEXT_MINOR_VERSION_ARB, profile.minor); } else { std::cerr << "warning: OpenGL ES " << profile.major << " requested but WGL_EXT_create_context_es_profile or WGL_EXT_create_context_es2_profile not supported\n"; } } else { assert(0); } if (debug) { contextFlags |= WGL_CONTEXT_DEBUG_BIT_ARB; } if (contextFlags) { attribs.add(WGL_CONTEXT_FLAGS_ARB, contextFlags); } attribs.end(); HGLRC new_hglrc; new_hglrc = pfnWglCreateContextAttribsARB(hDC, shareContext ? shareContext->hglrc : 0, attribs); if (!new_hglrc) { if (required) { std::cerr << "error: wglCreateContextAttribsARB failed\n"; exit(1); } else { return false; } } wglDeleteContext(hglrc); hglrc = new_hglrc; return true; }
void cESBTL::pdbComputeSD(const std::string& fileIn1, const std::string& fileIn2, double& sqrDist, size_t& numAtom, const std::string& atomName) { checkExtension(fileIn1); checkExtension(fileIn2); // input 1 ESBTL::PDB_line_selector pdbSelector1; std::vector<ESBTL::Default_system> pdbSystems1; ESBTL::All_atom_system_builder<ESBTL::Default_system> pdbBuilder1(pdbSystems1, pdbSelector1.max_nb_systems()); require(ESBTL::read_a_pdb_file(fileIn1, pdbSelector1, pdbBuilder1, Occupancy_policy_all()), "cannot read PDB file"); require(!pdbSystems1.empty(), "No PDB system"); require( pdbSystems1.size() == 1, "More than one PDB system: pdbSystems1.size() = " + num2str(pdbSystems1.size())); require(!pdbSystems1[0].has_no_model(), "No model in 1st PDB system"); require( pdbSystems1[0].number_of_models() == 1, "More than one model in 1st PDB system: pdbSystems1[0].number_of_models() = " + num2str(pdbSystems1[0].number_of_models())); cSetPoint3<double> atomList1; for (ESBTL::Default_system::Models_iterator iterModel = pdbSystems1[0].models_begin(); iterModel != pdbSystems1[0].models_end(); iterModel++) { const ESBTL::Default_system::Model& model = *iterModel; for (ESBTL::Default_system::Model::Atoms_const_iterator iterAtom = model.atoms_begin(); iterAtom != model.atoms_end(); iterAtom++) { if ((atomName != "" && iterAtom->atom_name() == atomName) || atomName == "") { atomList1.push_back(cVector3<double>(iterAtom->x(),iterAtom->y(),iterAtom->z())); } } } // input 2 ESBTL::PDB_line_selector pdbSelector2; std::vector<ESBTL::Default_system> pdbSystems2; ESBTL::All_atom_system_builder<ESBTL::Default_system> pdbBuilder2(pdbSystems2, pdbSelector2.max_nb_systems()); require(ESBTL::read_a_pdb_file(fileIn2, pdbSelector2, pdbBuilder2, Occupancy_policy_all()), "cannot read PDB file"); require(!pdbSystems2.empty(), "No PDB system"); require( pdbSystems2.size() == 1, "More than one PDB system: pdbSystems2.size() = " + num2str(pdbSystems2.size())); require(!pdbSystems2[0].has_no_model(), "No model in 1st PDB system"); require( pdbSystems2[0].number_of_models() == 1, "More than one model in 1st PDB system: pdbSystems2[0].number_of_models() = " + num2str(pdbSystems2[0].number_of_models())); cSetPoint3<double> atomList2; for (ESBTL::Default_system::Models_iterator iterModel = pdbSystems2[0].models_begin(); iterModel != pdbSystems2[0].models_end(); iterModel++) { const ESBTL::Default_system::Model& model = *iterModel; for (ESBTL::Default_system::Model::Atoms_const_iterator iterAtom = model.atoms_begin(); iterAtom != model.atoms_end(); iterAtom++) { if ((atomName != "" && iterAtom->atom_name() == atomName) || atomName == "") { atomList2.push_back(cVector3<double>(iterAtom->x(),iterAtom->y(),iterAtom->z())); } } } numAtom = atomList1.size(); sqrDist = atomList1.computeSD(atomList2); }