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);
}
