Logo Search packages:      
Sourcecode: pymol version File versions

Pixmap.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 "Pixmap.h"
#include "OOMac.h"
#include "Util.h"

void PixmapInit(PyMOLGlobals * G, CPixmap * I, int width, int height)
{
  UtilZeroMem(I, sizeof(CPixmap));
  I->G = G;
  I->height = height;
  I->width = width;
  if((height >= 0) && (width >= 0)) {
    I->buffer = Alloc(unsigned char, 4 * height * width);
  }
}

CPixmap *PixmapNew(PyMOLGlobals * G, int width, int height)
{
  OOAlloc(G, CPixmap);
  PixmapInit(G, I, width, height);
  return I;
}

void PixmapInitFromBitmap(PyMOLGlobals * G, CPixmap * I, int width, int height,
                          unsigned char *bitmap, unsigned char *rgba, int sampling)
{
  if(I) {

    int x, y, bit_cnt;
    unsigned char cur = 0;
    unsigned char *src;
    unsigned char *dst;
    register unsigned char red, blue, green, alpha;
    PixmapInit(G, I, width * sampling, height * sampling);
    red = rgba[0];
    green = rgba[1];
    blue = rgba[2];
    alpha = rgba[3];
    UtilZeroMem(I->buffer, 4 * width * height);
    src = bitmap;
    dst = I->buffer;
    for(y = 0; y < height; y++) {
      bit_cnt = 7;
      for(x = 0; x < width; x++) {
        bit_cnt++;
        if(bit_cnt > 7) {
          cur = *(src++);
          bit_cnt = 0;
        }
        if(cur & 0x80) {
          *(dst++) = red;
          *(dst++) = green;
          *(dst++) = blue;
          *(dst++) = alpha;
        } else {
          *(dst++) = 0;
          *(dst++) = 0;
          *(dst++) = 0;
          *(dst++) = 0;
        }
        cur <<= 1;
      }
    }
    if(sampling > 1) {
      unsigned int *p, *pp, *q, *row;
      int row_cnt, col_cnt, width_sampling = width * sampling;

      p = (unsigned int *) (I->buffer + 4 * width * height);
      q = (unsigned int *) (I->buffer + 4 * width * height * sampling * sampling);
      while(p > (unsigned int *) I->buffer) {
        row_cnt = sampling - 1;
        row = q;
        for(x = 0; x < width; x++) {    /* first row */
          col_cnt = sampling;
          p--;
          while(col_cnt--) {
            *(--q) = *p;
          }
        }
        if(row_cnt) {
          while(row_cnt--) {    /* remaining rows */
            pp = row;
            for(x = 0; x < width_sampling; x++) {
              *(--q) = *(--pp);
            }
          }
        }
      }
    }
  }
}

void PixmapInitFromBytemap(PyMOLGlobals * G, CPixmap * I,
                           int width,
                           int height,
                           int pitch,
                           unsigned char *bytemap,
                           unsigned char *rgba, unsigned char *outline_rgb, int flat)
{
  if(I) {

    int x, y;
    unsigned char *src, *sa, alp;
    unsigned char *dst;
    register unsigned char red, blue, green, alpha, no_alpha;
    register unsigned char ored = 0, oblue = 0, ogreen = 0;
    if(!outline_rgb[3])
      outline_rgb = NULL;
    else {
      ored = outline_rgb[0];
      oblue = outline_rgb[1];
      ogreen = outline_rgb[2];
    }
    PixmapInit(G, I, width, height);
    red = rgba[0];
    green = rgba[1];
    blue = rgba[2];
    alpha = rgba[3];
    UtilZeroMem(I->buffer, 4 * width * height);
    src = bytemap;
    dst = I->buffer;
    no_alpha = flat;
    for(y = 0; y < height; y++) {
      sa = src;
      if(no_alpha) {
        for(x = 0; x < width; x++) {
          alp = *(sa++);
          if(alp) {
            *(dst++) = red;
            *(dst++) = green;
            *(dst++) = blue;
            *(dst++) = 0xFF;
          } else {
            *(dst++) = 0;
            *(dst++) = 0;
            *(dst++) = 0;
            *(dst++) = 0;
          }
        }
      } else {
        for(x = 0; x < width; x++) {
          if(outline_rgb) {
            unsigned char amax = 0, amin;
            if(y > 0) {
              alp = 255 - *(sa - pitch);
            } else {
              alp = 255;
            }
            if(amax < alp)
              amax = alp;
            if(y < (height - 1)) {
              alp = 255 - *(sa + pitch);
            } else {
              alp = 255;
            }
            if(amax < alp)
              amax = alp;
            if(x > 0) {
              alp = 255 - *(sa - 1);
            } else {
              alp = 255;
            }
            if(amax < alp)
              amax = alp;
            if(x < (width - 1)) {
              alp = 255 - *(sa + 1);
            } else {
              alp = 255;
            }
            if(amax < alp)
              amax = alp;
            amin = 255 - amax;
            alp = *(sa++);
            if(alp) {
              *(dst++) = (red * amin + ored * amax) / 255;
              *(dst++) = (green * amin + ogreen * amax) / 255;
              *(dst++) = (blue * amin + oblue * amax) / 255;
              *(dst++) = (alpha * alp) / 255;
            } else {
              *(dst++) = 0;
              *(dst++) = 0;
              *(dst++) = 0;
              *(dst++) = 0;
            }
          } else {
            alp = *(sa++);
            if(alp) {
              *(dst++) = red;
              *(dst++) = green;
              *(dst++) = blue;
              *(dst++) = (alpha * alp) >> 8;
            } else {
              *(dst++) = 0;
              *(dst++) = 0;
              *(dst++) = 0;
              *(dst++) = 0;
            }
          }

        }
      }
      src += pitch;
    }
  }
}

void PixmapPurge(CPixmap * I)
{
  if(I) {
    FreeP(I->buffer);
  }
}

void PixmapFreeP(CPixmap * I)
{
  PixmapPurge(I);
  OOFreeP(I);
}

Generated by  Doxygen 1.6.0   Back to index