Logo Search packages:      
Sourcecode: pymol version File versions

RepEllipsoid.c

/* 
   A* -------------------------------------------------------------------
   B* This file contains source code for the PyMOL computer program
   C* copyright 1998-2000 by Warren Lyford Delano of DeLano Scientific. 
   D* -------------------------------------------------------------------
   E* It is unlawful to modify or remove this copyright notice.
   F* -------------------------------------------------------------------
   G* Please see the accompanying LICENSE file for further information. 
   H* -------------------------------------------------------------------
   I* Additional authors of this source file include:
   -* 
   -* 
   -*
   Z* -------------------------------------------------------------------
*/

#include"os_predef.h"
#include"os_std.h"
#include"os_gl.h"

#include"Base.h"
#include"OOMac.h"
#include"RepEllipsoid.h"
#include"Color.h"
#include"Setting.h"
#include"Feedback.h"
#include"Matrix.h"
#include"CGO.h"

typedef struct RepEllipsoid {
  Rep R;                        /* must be first! */
  CGO *ray, *std;
} RepEllipsoid;

#include"ObjectMolecule.h"

void RepEllipsoidFree(RepEllipsoid * I);

void RepEllipsoidFree(RepEllipsoid * I)
{
  if(I->ray)
    CGOFree(I->ray);
  if(I->std)
    CGOFree(I->std);
  RepPurge(&I->R);
  OOFreeP(I);
}

static void RepEllipsoidRender(RepEllipsoid * I, RenderInfo * info)
{
  CRay *ray = info->ray;
  Picking **pick = info->pick;
  register PyMOLGlobals *G = I->R.G;
  if(ray) {
    PRINTFD(G, FB_RepEllipsoid)
      " RepEllipsoidRender: rendering ray...\n" ENDFD;

    if(I->ray)
      CGORenderRay(I->ray, ray, NULL, I->R.cs->Setting, I->R.obj->Setting);
    else if(I->std)
      CGORenderRay(I->std, ray, NULL, I->R.cs->Setting, I->R.obj->Setting);
  } else if(G->HaveGUI && G->ValidContext) {

    if(pick) {
      if(I->std) {
        CGORenderGLPicking(I->std, pick, &I->R.context,
                           I->R.cs->Setting, I->R.obj->Setting);
      }
    } else {
      int use_dlst;
      use_dlst = (int) SettingGet(G, cSetting_use_display_lists);
      if(use_dlst && I->R.displayList) {
        glCallList(I->R.displayList);
      } else {

        if(use_dlst) {
          if(!I->R.displayList) {
            I->R.displayList = glGenLists(1);
            if(I->R.displayList) {
              glNewList(I->R.displayList, GL_COMPILE_AND_EXECUTE);
            }
          }
        }

        PRINTFD(G, FB_RepEllipsoid)
          " RepEllipsoidRender: rendering GL...\n" ENDFD;
        if(I->std)
          CGORenderGL(I->std, NULL, I->R.cs->Setting, I->R.obj->Setting, info);

        if(use_dlst && I->R.displayList) {
          glEndList();
        }
      }
    }
  }
}

const double problevel[50] = { 0.4299, 0.5479, 0.6334, 0.7035, 0.7644,
  0.8192, 0.8694, 0.9162, 0.9605, 1.0026,
  1.0430, 1.0821, 1.1200, 1.1570, 1.1932,
  1.2288, 1.2638, 1.2985, 1.3330, 1.3672,
  1.4013, 1.4354, 1.4695, 1.5037, 1.5382,
  1.5729, 1.6080, 1.6436, 1.6797, 1.7164,
  1.7540, 1.7924, 1.8318, 1.8724, 1.9144,
  1.9580, 2.0034, 2.0510, 2.1012, 2.1544,
  2.2114, 2.2730, 2.3404, 2.4153, 2.5003,
  2.5997, 2.7216, 2.8829, 3.1365, 6.0000
};

Rep *RepEllipsoidNew(CoordSet * cs, int state)
{
  PyMOLGlobals *G = cs->State.G;
  ObjectMolecule *obj;

  OOCalloc(G, RepEllipsoid);    /* allocates & sets I */

  obj = cs->Obj;

  {
    int visible_flag = false;
    int a;
    visible_flag = false;
    if(obj->RepVisCache[cRepEllipsoid])
      for(a = 0; a < cs->NIndex; a++) {
        if(obj->AtomInfo[cs->IdxToAtm[a]].visRep[cRepEllipsoid]) {
          visible_flag = true;
          break;
        }
      }
    if(!visible_flag) {
      OOFreeP(I);
      return (NULL);            /* skip if no dots are visible */
    }
  }

  RepInit(G, &I->R);

  I->R.fRender = (void (*)(struct Rep *, RenderInfo *)) RepEllipsoidRender;
  I->R.fFree = (void (*)(struct Rep *)) RepEllipsoidFree;
  I->R.cs = cs;
  I->R.obj = (CObject *) obj;
  I->R.context.object = (void *) obj;
  I->R.context.state = state;

  /*  I->R.fSameVis=(int (*)(struct Rep*, struct CoordSet*))RepEllipsoidSameVis; */

  {
    int ellipsoid_color = SettingGet_color(G, cs->Setting, obj->Obj.Setting,
                                           cSetting_ellipsoid_color);

    int cartoon_side_chain_helper = SettingGet_b(G, cs->Setting, obj->Obj.Setting,
                                                 cSetting_cartoon_side_chain_helper);

    int ribbon_side_chain_helper = SettingGet_b(G, cs->Setting, obj->Obj.Setting,
                                                cSetting_ribbon_side_chain_helper);

    float ellipsoid_scale = SettingGet_f(G, cs->Setting, obj->Obj.Setting,
                                         cSetting_ellipsoid_scale);

    float transp = SettingGet_f(G, cs->Setting, obj->Obj.Setting,
                                cSetting_ellipsoid_transparency);

    int pickable = SettingGet_b(G, cs->Setting, obj->Obj.Setting,
                                cSetting_pickable);

    float prob = SettingGet_f(G, cs->Setting, obj->Obj.Setting,
                              cSetting_ellipsoid_probability);
    double matrix_factor = 0.0F;
    float pradius = 0.0F;
    {

      int iprob = (prob + 0.01F) * 50.0F - 1;
      if(iprob < 0)
        iprob = 0;
      if(iprob > 49)
        iprob = 49;
      pradius = problevel[iprob];
      matrix_factor = -(1 / (pradius * pradius));
    }

    I->ray = CGONew(G);         /* describe the ellipsoids analytically */

    if(I->ray) {
      int a, a1;
      int vis_flag;
      AtomInfoType *ai;
      float last_alpha = 1.0F;

      for(a = 0; a < cs->NIndex; a++) {
        a1 = cs->IdxToAtm[a];
        ai = obj->AtomInfo + a1;
        vis_flag = ai->visRep[cRepEllipsoid];

        if(vis_flag &&
           (!ai->hetatm) &&
           ((cartoon_side_chain_helper && ai->visRep[cRepCartoon]) ||
            (ribbon_side_chain_helper && ai->visRep[cRepRibbon]))) {

          register char *name1 = ai->name;
          register int prot1 = ai->protons;

          if(prot1 == cAN_N) {
            if((!name1[1]) && (name1[0] == 'N')) {      /* N */
              register char *resn1 = ai->resn;
              if(!((resn1[0] == 'P') && (resn1[1] == 'R') && (resn1[2] == 'O')))
                vis_flag = false;
            }
          } else if(prot1 == cAN_O) {
            if((!name1[1]) && (name1[0] == 'O'))
              vis_flag = false;
          } else if(prot1 == cAN_C) {
            if((!name1[1]) && (name1[0] == 'C'))
              vis_flag = false;
          }
        }

        if(vis_flag) {
          double u11, u22, u33, u12, u13, u23;

          u11 = ai->U11;
          u22 = ai->U22;
          u33 = ai->U33;
          u12 = ai->U12;
          u13 = ai->U13;
          u23 = ai->U23;
          if(u11 || u22 || u33 || u12 || u13 || u23) {
            int n_rot;
            double matrix[16];
            double e_val[4];
            double e_vec[16];

            matrix[0] = u11;
            matrix[1] = u12;
            matrix[2] = u13;
            matrix[3] = 0.0;
            matrix[4] = u12;
            matrix[5] = u22;
            matrix[6] = u23;
            matrix[7] = 0.0;
            matrix[8] = u13;
            matrix[9] = u23;
            matrix[10] = u33;
            matrix[11] = 0.0;
            matrix[12] = 0.0;
            matrix[13] = 0.0;
            matrix[14] = 0.0;
            matrix[15] = matrix_factor;

            if(xx_matrix_jacobi_solve(e_vec, e_val, &n_rot, matrix, 4)) {

              float at_ellipsoid_scale;
              int at_ellipsoid_color;
              float at_transp;
              float *v = cs->Coord + 3 * a;

              float mag[3];
              float scale[3];

              float mx;
              float r_el, n0[3], n1[3], n2[3];
              int c1;

              AtomInfoGetSetting_f(G, ai, cSetting_ellipsoid_scale, ellipsoid_scale,
                                   &at_ellipsoid_scale);
              AtomInfoGetSetting_f(G, ai, cSetting_ellipsoid_transparency, transp,
                                   &at_transp);
              AtomInfoGetSetting_color(G, ai, cSetting_ellipsoid_color, ellipsoid_color,
                                       &at_ellipsoid_color);

              if(at_ellipsoid_color == -1)
                c1 = *(cs->Color + a);
              else
                c1 = at_ellipsoid_color;

              n0[0] = e_vec[0];
              n0[1] = e_vec[4];
              n0[2] = e_vec[8];
              n1[0] = e_vec[1];
              n1[1] = e_vec[5];
              n1[2] = e_vec[9];
              n2[0] = e_vec[2];
              n2[1] = e_vec[6];
              n2[2] = e_vec[10];

              normalize3f(n0);
              normalize3f(n1);
              normalize3f(n2);
              mag[0] = sqrt1f(e_val[0]);
              mag[1] = sqrt1f(e_val[1]);
              mag[2] = sqrt1f(e_val[2]);

              mx = mag[0];
              if(mx < mag[1])
                mx = mag[1];
              if(mx < mag[2])
                mx = mag[2];

              scale[0] = mag[0] / mx;
              scale[1] = mag[1] / mx;
              scale[2] = mag[2] / mx;

              scale3f(n0, scale[0], n0);
              scale3f(n1, scale[1], n1);
              scale3f(n2, scale[2], n2);

              r_el = mx * pradius * ellipsoid_scale;

              {
                float vc[3];
                if(ColorCheckRamped(G, c1)) {
                  ColorGetRamped(G, c1, v, vc, state);
                  CGOColorv(I->ray, vc);
                } else {
                  CGOColorv(I->ray, ColorGet(G, c1));
                }
              }

              {
                float alpha = 1.0F - at_transp;
                if(alpha != last_alpha) {
                  CGOAlpha(I->ray, alpha);
                  last_alpha = alpha;
                }
              }
              if(pickable && (!ai->masked))
                CGOPickColor(I->ray, a1, cPickableAtom);

              CGOEllipsoid(I->ray, v, r_el, n0, n1, n2);
            }
          }
        }
      }
      CGOStop(I->ray);
      I->std = CGOSimplify(I->ray, 0);  /* convert analytical to discrete */
    }
  }
  return ((void *) (struct Rep *) I);
}

Generated by  Doxygen 1.6.0   Back to index