ClusterViz-0.2.tar

ClusterViz-0.2/0000755000175000001440000000000010405136430013170 5ustar  maaskolausersClusterViz-0.2/clusterdisplay.py0000755000175000001440000005401410405127320016616 0ustar  maaskolausers#
#    clusterdisplay.py - visualization routines to display clustering processes
#
#    Copyright (C) 2005  Janne Grunau, Jonas Maaskola
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#

"""This script displays a visualization of the clustering process of the family
of kmeans-algorithms."""

import colorsys, logging, Numeric, random, sys, time, threading
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

import trackball
import visualkmeans
import guihelp
import auxiliary

DEBUGGING = 0

try:
    import rpy
except ImportError:
    rpy_available = False
else:
    rpy_available = True

class clusterDisplay:
  """ Class to incorporate the facilities to visualize a clustering process. """
  def __init__(self,
               data,
               k,
               transformation_matrix,
               redraw_event = threading.Event(),
               width = 800,
               height = 600,
               title = "Clustering using Python and OpenGL",
               logger = None):
    """ Intialize a clustering display.
    Arguements are:
    data          a list of the three-dimensional data points
    k             the number of clusters in the kmeans algorithm
    redraw_event  an object used flag when to readraw and when not
    width         width of the window to be created
    height        height of the window to be created
    title         the title to be displayed in the window
    logger        a logging facility
    """
    if logger is None:
      # Organize logging.
      self.logger = logging.getLogger("clusterDisplay")
      hdlr = logging.StreamHandler()
      if not bool(DEBUGGING):
        self.logger.setLevel(logging.INFO)
        formatter = logging.Formatter('%(message)s')
#       formatter = logging.Formatter('%(asctime)s Display %(levelname)s %(message)s')
      else:
        self.logger.setLevel(logging.DEBUG)
        formatter = logging.Formatter('Display    %(levelname)s %(message)s')
#       formatter = logging.Formatter('%(asctime)s Display %(levelname)s %(message)s')
      hdlr.setFormatter(formatter)
      self.logger.addHandler(hdlr)
    else:
      self.logger = logger

    self.width = int(width)
    self.height = int(height)
    self.title = title
    self.data = data
    self.dataLen = len(self.data)
    self.k = k
    self.transformation_matrix = transformation_matrix
    self.redraw_event = redraw_event
    self.glutPostRedisplayLOCK = threading.Lock()
    self.historyLocked = False
    
    if self.transformation_matrix is not None:
        self.data = Numeric.dot(data, transformation_matrix)

    self.entropy = []
    self.dataColors = []
    for i in xrange(self.dataLen): self.dataColors.append([1.0, 1.0, 1.0, 1.0])
    self.center = Numeric.sum(self.data)/self.dataLen  # Set Center to the data mean
    self.logger.info("Center of data = "+str(self.center))
    self.clusterpositions = []
    self.clusterhistory = []
    self.sigmahistory = []
    self.colors = []

    self.showTrajectories = True

    self.zoomFactor = 1.0

    ##//------ Trackball ------------
    self.mouse_button = 0

    self.drawData = True
    self.drawClusters = True
    self.cluster_rep_radius = 1.0

    self.data_transparency = 0.8
    self.line_width = 2.0
    self.pointsize = 2.5 * 10
    self.cluster_trans = 0.3
    self.sphere_segments = 50
    self.rel_axis_length = 1.0

    self.timeIDX = 0
    self.clusteringDone = False
    self.displayPointInTime = None

    self.show_gui_help = False
    self.readmefile = "README"
    self.statusText = "%i data points displayed" % self.dataLen
    self.gui_help_text = guihelp.gui_help_text
    self.DLs_initialized = False

    self.regenData = False
    self.clusteringPaused = False
    self.clusteringThread = None
    self.clusteringRestart = False
    self.Exit = False


  def initGL(self):
    """ Intialize the OpenGL system by calling functions that set up the
    lightning, shading, generate display lists and set up the trackball."""
    ambient = [ 0.0, 0.0, 0.0, 0.0 ]
    lmodel_ambient = [ 1.0, 1.0, 1.0, 1.0 ]
    diffuse = [ 0.0, 0.0, 0.0, 0.0 ]
    lightposition = [ 5.0, 10.0, 20.0, 0.0 ]
    local_view = [ 0.0 ]


    glLight(GL_LIGHT0, GL_AMBIENT, ambient)
    glLightModel(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient)

    glLight(GL_LIGHT0, GL_DIFFUSE, diffuse)
    glLight(GL_LIGHT0, GL_POSITION, lightposition)
    glLightModel(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient)
    glLightModel(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view)


    glEnable(GL_DEPTH_TEST)
    glDepthFunc(GL_LESS)

    glEnable(GL_CULL_FACE)

    glEnable(GL_LIGHTING)
    glEnable(GL_LIGHT0)
    glEnable(GL_BLEND)
    glBlendFunc(GL_SRC_ALPHA,  GL_ONE_MINUS_SRC_ALPHA)
    glShadeModel(GL_SMOOTH)
    glEnable(GL_ALPHA_TEST)
    glAlphaFunc(GL_GREATER,0)
    glEnable(GL_POINT_SMOOTH)

    self.maximized = False
    self.DLs_initialized = False
    self.generate_display_lists()

    self.tb = trackball.trackball()
    self.tb.gltbInit(GLUT_LEFT_BUTTON)
    
    self.logger.debug("GL settings initialized.")

  def generate_display_lists(self):
    """ Generate display lists. """
    self.dataRepDL = glGenLists(1)          # draws the data points
    glNewList(self.dataRepDL,GL_COMPILE)
    self.draw_data_representation()
    glEndList()

    self.crossDL = glGenLists(1)            # draws a 3d-cross
    glNewList(self.crossDL,GL_COMPILE)
    self.draw_3d_cross()
    glEndList()

    self.DLs_initialized = True

  def regen_data_display_list(self):
    """ (Re-) Generate data representation display list. """
    if self.DLs_initialized:
      self.dataRepDL = glGenLists(1)          # draws the data points
      glNewList(self.dataRepDL,GL_COMPILE)
      self.draw_data_representation()
      glEndList()
    else:
      self.logger.error("Trying to recalculate the colors too early.")

  def draw_text(self, value, x,y,  font = GLUT_BITMAP_8_BY_13, step = 18):
    """Draw the given text at given 2D position in window.
    Possiblities for the font include:
    GLUT_BITMAP_8_BY_13
    GLUT_BITMAP_9_BY_15
    GLUT_BITMAP_TIMES_ROMAN_10
    GLUT_BITMAP_TIMES_ROMAN_24
    GLUT_BITMAP_HELVETICA_10
    GLUT_BITMAP_HELVETICA_12
    GLUT_BITMAP_HELVETICA_18
    For reference see:
    http://pyopengl.sourceforge.net/documentation/manual/glutBitmapCharacter.3GLUT.html
    """
    glMatrixMode(GL_PROJECTION)
    glPushMatrix()

    glLoadIdentity()
    glOrtho(0.0, self.height or 32, 0.0, self.width or 32, -1.0, 1.0)
    glMatrixMode(GL_MODELVIEW)
    glPushMatrix()
    glLoadIdentity()
    glRasterPos2i(x, y)
    lines = 0
    for character in value:
      if character == '\n':
        glRasterPos2i(x, y-(lines*step))
        lines += 1
      else:
        glutBitmapCharacter(font, ord(character))
    glPopMatrix()
    glMatrixMode(GL_PROJECTION)
    glPopMatrix()
    glMatrixMode(GL_MODELVIEW)

  def draw_help_info(self):
    """ Writes self.gui_help_text approximately in the middle of the screen. """
    glMaterial(GL_FRONT, GL_AMBIENT, (1.0,1.0,1.0,1.0))
    glMaterial(GL_FRONT, GL_DIFFUSE, (1.0,1.0,1.0,1.0))
    self.draw_text(self.gui_help_text,50,self.height-10)
    #for i in range(self.height/20):
    #  self.draw_text(("Test %3i: h = %i" %(i, self.height)), 10, i*20)

  def draw_status_info(self):
    """ Writes self.statusText into a line at the bottom of the screen. """
    glMaterial(GL_FRONT, GL_AMBIENT, (1.0,1.0,1.0,1.0))
    glMaterial(GL_FRONT, GL_DIFFUSE, (1.0,1.0,1.0,1.0))
    self.draw_text(self.statusText,10,10, GLUT_BITMAP_HELVETICA_18)

  def draw_data_representation(self):
    """ Draw data representations. """
    glPointSize(self.pointsize)
    glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
    glEnable(GL_COLOR_MATERIAL)

    glVertexPointerd(self.data)
    glEnableClientState(GL_VERTEX_ARRAY)

    glColorPointerd(self.dataColors)
    glEnableClientState(GL_COLOR_ARRAY)

    glDrawArrays(GL_POINTS, 0, self.dataLen)

    glDisable( GL_VERTEX_ARRAY )
    glDisable( GL_COLOR_ARRAY )
    glDisable( GL_COLOR_MATERIAL )

  def draw_3d_cross(self):
      """ Draws a stippled three-dimensional cross. """
      glEnable(GL_LINE_STIPPLE)
      glLineStipple(1,0x00FF) # magic numbers 10101010101010
      glMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE, (1.0,1.0,1.0,1.0))
      glMaterial(GL_FRONT, GL_AMBIENT, (1.0,1.0,1.0,1.0))
      glLineWidth(self.line_width)
      glBegin(GL_LINE_STRIP)
      glVertex3f(-1.0, 0.0, 0.0)
      glVertex3f(1.0, 0.0, 0.0)
      glEnd()
      glBegin(GL_LINE_STRIP)
      glVertex3f(0.0, -1.0, 0.0)
      glVertex3f(0.0, 1.0, 0.0)
      glEnd()
      glBegin(GL_LINE_STRIP)
      glVertex3f(0.0, 0.0, -1.0)
      glVertex3f(0.0, 0.0, 1.0)
      glEnd()
      glDisable(GL_LINE_STIPPLE)

  def draw_cluster_representations(self):
    """ Draw cluster representations: transparent spheres and stippled diameter lines. """
    idx = 0
    for cluster in self.clusterpositions:
      glPushMatrix()
      # Move to cluster center
      glTranslate(cluster[0], cluster[1], cluster[2])
      # Scale according to cluster's standard deviations' axiparallel extents
      glScale(self.sdevs[idx][0] * self.cluster_rep_radius, self.sdevs[idx][1] * self.cluster_rep_radius, self.sdevs[idx][2] * self.cluster_rep_radius)
 
      # Draw cluster sphere diameters
      glPushMatrix()
      glMaterial(GL_FRONT, GL_AMBIENT, (1.0,1.0,1.0,1.0))
      glMaterial(GL_FRONT, GL_DIFFUSE, (1.0,1.0,1.0,1.0))
      glScale(self.rel_axis_length, self.rel_axis_length, self.rel_axis_length)
      glCallList(self.crossDL)
      glPopMatrix()

      # Draw actual spheres
      glMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE, self.colors[idx])
      glMaterial(GL_FRONT, GL_AMBIENT, self.colors[idx])
      glutSolidSphere(1.0, self.sphere_segments, self.sphere_segments)

      glPopMatrix()
      idx += 1

  def draw_cluster_trajectories(self):
    """ Draw cluster trajectories. """

    # First draw stippled opaque white trajectory
    glEnable(GL_LINE_STIPPLE)
    glLineStipple(1,0x00FF) # magic numbers 10101010101010
    glLineWidth(self.line_width)
    glMaterial(GL_FRONT, GL_AMBIENT, (1.0,1.0,1.0,1.0))
    glMaterial(GL_FRONT, GL_DIFFUSE, (1.0,1.0,1.0,1.0))
    for clustertrajectory in self.clusterhistory:
      glBegin(GL_LINE_STRIP)
      for point in clustertrajectory[:self.timeIDX+1]:
        glVertex3f(point[0], point[1], point[2])
      glEnd()
    glDisable(GL_LINE_STIPPLE)

    # Then draw semi transparent colorful trajectory
    glLineWidth(self.line_width*2)
    color = 0
    for clustertrajectory in self.clusterhistory:
      glBegin(GL_LINE_STRIP)
      glMaterial(GL_FRONT, GL_AMBIENT, self.colors[color])
      glMaterial(GL_FRONT, GL_DIFFUSE, self.colors[color])
      color += 1
      for point in clustertrajectory[:self.timeIDX+1]:
        glVertex3f(point[0], point[1], point[2])
      glEnd()

  def display(self):
    self.redraw_event.clear()

    if self.regenData:
      self.regen_data_display_list()
      self.regenData = False

    glPushMatrix()
    glClearColor(0.0, 0.0, 0.0, 0.0)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    # Transform according to trackball status
    self.tb.gltbMatrix()

    # Move objects into the center of view (hopefully)
    # Mind that self.center is the mean of the data.
    glTranslate(-self.center[0],-self.center[1],-self.center[2])

    # Draw status info
    self.draw_status_info()

    # Draw data
    if self.drawData:
        glCallList(self.dataRepDL)

    # Draw cluster trajectories
    if self.showTrajectories:
      self.draw_cluster_trajectories()

    # Draw cluster representations: transparent spheres and stippled diameter lines
    if self.drawClusters:
        self.draw_cluster_representations()
    
    # Draw GUI usage info
    if self.show_gui_help:
        self.draw_help_info()

    glPopMatrix()
    glutSwapBuffers()

    # Restart the Clustering
    if self.clusteringRestart:
        if not self.clusteringThread.isAlive():
            self.clusteringThread = self.clThreadReInit()
            self.clusteringThread.start()
            self.clusteringRestart = False

    # test for exit
    if self.Exit:
        if not self.clusteringThread.isAlive():
            sys.exit(0)


  def clThreadReInit(self):

      self.entropy = []

      data      = self.clusteringThread.seqs
      display   = self
      k         = self.clusteringThread.k
      dist      = self.clusteringThread.distanceFunction
      algorithm = self.clusteringThread.algorithm
      redraw_ev = self.redraw_event
      beta      = self.clusteringThread.beta

      return visualkmeans.Clustering(data, display, k, dist, algorithm, redraw_ev, beta)


  def reshape(self, width, height):

        self.width = width
        self.height = height

        if height==0:
            return

        # Trackball
        self.tb.gltbReshape(width, height)

        glViewport(0, 0,  width, height)
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        gluPerspective(45.0*self.tb.zoomFactor, width/height, 1.0, 100.0)
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()
        glTranslatef(0.0, 0.0, -18.0)


  def keyboard (self, key, x, y):
    #self.logger.debug(str(key)+" "+str(int(key)))
    ## FULLSCREEN
    if key == 'f':
        if not self.maximized:
            glutFullScreen()
            self.maximized = True
            self.window_x = glutGet(GLUT_WINDOW_X)
            self.window_y = glutGet(GLUT_WINDOW_Y)
            self.window_width = glutGet(GLUT_WINDOW_WIDTH)
            self.window_height = glutGet(GLUT_WINDOW_HEIGHT)
    ## WINDOWED
    elif key == 'w':
        if self.maximized:
            glutPositionWindow(self.window_x, self.window_y)
            #glutReshapeWindow(400,200)
            glutReshapeWindow(self.window_width, self.window_height)
            self.maximized = False
    ## HELP
    elif key == 'h':
         self.show_gui_help = not self.show_gui_help
    ## QUIT
    elif key == "q" or ord(key) == 27:
        self.statusText = "Exiting"
        self.clusteringThread.abortNOW = True
        self.Exit = True
    ## HISTORY_BACK
    elif key == 'b':
        if self.clusteringDone:
            if not self.historyLocked:
                self.historyLocked = True
                self.displayHistoryItem(-1)
                self.regen_data_display_list()
        else:
            self.statusText = "Please wait until clustering process has finished."
    ## HISTORY_NEXT
    elif key == 'n':
        if self.clusteringDone:
            if not self.historyLocked:
                self.historyLocked = True
                self.displayHistoryItem(+1)
                self.regen_data_display_list()
        else:
            self.statusText = "Please wait until clustering process has finished."
    ## TOGGLE_TRAJECTORIES_DISPLAY
    elif key  =='j':
        self.showTrajectories = not self.showTrajectories
        self.statusText = "Show trajectories: %s." % str(self.showTrajectories)
    ## TOGGLE_DATA_DISPLAY
    elif key == 'd':
         self.drawData = not self.drawData
         self.statusText = "Draw data points: %s." % str(self.drawData)
         if self.drawData:
           self.regen_data_display_list()
    ## TOGLE_CLUSTER_REPRESENTATIONS_DISPLAY
    elif key == 'c':
        self.drawClusters = not self.drawClusters
        self.statusText = "Draw cluster centers: %s." % str(self.drawClusters)
    ## RESTART_CLUSTERING
    elif key == 'r':
        if not self.clusteringRestart:
            self.statusText = "Restarting cluster computation"
            self.clusteringThread.abortNOW = True
            self.clusteringRestart = True
    ## PAUSE_CLUSTERING
    elif key == 'p':
        self.clusteringPaused = not self.clusteringPaused
        self.statusText = "Clustering thread paused: %s." % str(self.clusteringPaused)

    if self.glutPostRedisplayLOCK.acquire(False):
        glutPostRedisplay()
        self.glutPostRedisplayLOCK.release()


  def mouse(self, button, state, x, y):

        #/* fix for two-button mice -- left mouse + shift = middle mouse */
        if (button == GLUT_LEFT_BUTTON and glutGetModifiers() & GLUT_ACTIVE_SHIFT):
            button = GLUT_MIDDLE_BUTTON

        #save mouse state
        self.mouse_button = button
        self.mouse_x= x
        self.mouse_y= y

        if (state == GLUT_DOWN) and (button==GLUT_LEFT_BUTTON):
            self.tb.gltbStartMotion(x, y, button, glutGet(GLUT_ELAPSED_TIME))
        elif (state == GLUT_UP) and (button==GLUT_LEFT_BUTTON):
            self.tb.gltbStopMotion(button, glutGet(GLUT_ELAPSED_TIME))


  def motion(self, x, y):

        #rotation
        if self.mouse_button == GLUT_LEFT_BUTTON:
              self.tb.gltbMotion(x, y)

        #zooming
        elif self.mouse_button == GLUT_RIGHT_BUTTON:
            self.tb.gltbZoom(x, y, self.mouse_x, self.mouse_y)

        #panning
        elif self.mouse_button == GLUT_MIDDLE_BUTTON:
            self.tb.gltbPan(x, y, self.mouse_x, self.mouse_y)

        # save mouse position
        self.mouse_x= x
        self.mouse_y= y

        if self.glutPostRedisplayLOCK.acquire(False):
            glutPostRedisplay()
            self.glutPostRedisplayLOCK.release()


  def idle(self):
    if not self.clusteringPaused:
      self.redraw_event.set()
    if self.tb.animate:
      self.glutPostRedisplayLOCK.acquire(True)
      self.tb.gltbAnimate()
      self.glutPostRedisplayLOCK.release()
    time.sleep(0.01)
    self.historyLocked = False

  def changeAssignment(self, point, cluster_ptr, entropy):
    """ Assign one data point to a cluster. The data point's cluster
    distribution's entropy is also given. """
    self.dataColors[point] = [(1-entropy) * ko + entropy 
        for ko in self.colors[cluster_ptr]][:-1] + [self.data_transparency]

  def clearClusters(self,k):
    """ Reset everything touching the cluster representations to k at zero. """
    self.k = k
    self.clusterpositions = []
    self.clusterhistory = []
    self.sdevs = []
    self.sigmahistory = []
    for i in range(k):
      self.clusterpositions.append((0.0,0.0,0.0))
      self.clusterhistory.append([])
      self.sigmahistory.append([])
      self.sdevs.append((0.0,0.0,0.0))

    self.colors = []
    for x in range(k):
      self.colors.append(colorsys.hls_to_rgb(float(x)/k ,0.5,1.0) + (self.cluster_trans,))
    self.logger.debug("Colors: "+str(self.colors))
    if self.glutPostRedisplayLOCK.acquire(False):
        glutPostRedisplay()
        self.glutPostRedisplayLOCK.release()


  def updateCluster(self, cluster_nr, pos, sdevs = (1.0,1.0,1.0)):
    self.logger.info("Cluster "+str(cluster_nr)+" updated to "+str(pos))
    if self.transformation_matrix is not None:
        pos = Numeric.dot(pos,self.transformation_matrix)
    self.clusterpositions[cluster_nr] = pos
    self.sdevs[cluster_nr] = sdevs
    if not self.clusteringDone:
        self.clusterhistory[cluster_nr].append(pos)
        self.sigmahistory[cluster_nr].append(sdevs)
        self.timeIDX = len(self.clusterhistory[0])-1
    
    if self.glutPostRedisplayLOCK.acquire(False):
        self.redraw_event.clear()
        glutPostRedisplay()
        self.glutPostRedisplayLOCK.release()


  def addEntropy(self, v):
    if (rpy_available):
      self.entropy.append(v)
      rpy.r.plot(self.entropy,main="Entropy of data distribution over the clusters",xlab="Clustering update steps",ylab="Nats")


  def enableHistory (self, displayfunction):
      self.clusteringDone = True
      self.displayPointInTime = displayfunction
      self.timeIDX = len(self.clusterhistory[0])-1
      self.statusText = "Calculation finished."
      
      if self.glutPostRedisplayLOCK.acquire(False):
        glutPostRedisplay()
        self.glutPostRedisplayLOCK.release()


  def displayHistoryItem (self, step):
    assert self.clusteringDone
    if self.timeIDX+step >= len(self.clusterhistory[0]) or self.timeIDX+step < 0:
              self.logger.info("End of history reached at step " + str(self.timeIDX))
              self.statusText = "Time index = "+str(self.timeIDX)+" (start/end of history)"
    else:
              self.timeIDX += step
              reps = []
              sigma = []
              k = len(self.clusterhistory)
              for clustertrajec in self.clusterhistory:
                  reps.append(clustertrajec[self.timeIDX])
              for s in self.sigmahistory:
                  sigma.append(s[self.timeIDX])
              self.logger.info("Displaying time point " + str(self.timeIDX))
              self.displayPointInTime (k, reps, sigma, .01)
              self.statusText = "Time index = "+str(self.timeIDX)
              
    if self.glutPostRedisplayLOCK.acquire(False):
        glutPostRedisplay()
        self.glutPostRedisplayLOCK.release()


  def updateDisplay(self):
      self.redraw_event.clear()
      if self.glutPostRedisplayLOCK.acquire(False):
          glutPostRedisplay()
          self.glutPostRedisplayLOCK.release()


  def mainLoop(self):
    random.seed()

    self.logger.debug("Initializing display.")
    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH)
    glutInitWindowSize(self.width,self.height) 
    glutInitWindowPosition(0, 0)
    glutCreateWindow(self.title)

    self.initGL()

    glutDisplayFunc(self.display) 
    glutReshapeFunc(self.reshape)
    glutKeyboardFunc(self.keyboard)
    glutMouseFunc(self.mouse)
    glutMotionFunc(self.motion)
    glutIdleFunc(self.idle)
    self.logger.debug("Display intialization finished. Entering main loop.")

    glutMainLoop()

if __name__ == "__main__":
  cl = clusterDisplay(auxiliary.readData())
  cl.clearClusters(3)
  cl.updateCluster(cl.data[0], 0)
  cl.updateCluster(cl.data[1], 1)
  cl.updateCluster(cl.data[2], 2)
  for i in range(len(cl.data)):
    cl.changeAssignment(i, i%3,0.5)
  cl.mainLoop()
ClusterViz-0.2/CREDITS0000644000175000001440000000040510400367054014212 0ustar  maaskolausersFor a description of the algorithms we refer to the nice book "Information
Theory, Inference and Learning Algorithms" by David J.C. MacKay.

The project started off with an implementation of the k-means algorithm which
was written in 2003 by Alexander Schliep.
ClusterViz-0.2/trackball.py0000755000175000001440000001074110400367054015512 0ustar  maaskolausers# -*- coding: iso8859_15 -*-
##/*
## *  Simple trackball-like motion adapted (ripped off) from projtex.c
## *  (written by David Yu and David Blythe).  See the SIGGRAPH '96
## *  Advanced OpenGL course notes.
## */


import math, sys, logging, os.path
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

GLTB_TIME_EPSILON = 10

class trackball:

    def __init__(self):
        self.lasttime = 0
        self.lastposition = [0, 0, 0]

        self.zoomFactor = 1.0

        self.angle = 0.0
        self.axis = [0.0, 0.0, 0.0]

        self.width  = 0
        self.height = 0

        self.button = -1
        self.tracking = False
        self.animate = False

        self.center = [0,0,0] # the point we're looking at, the eye point is center+[0,0,-1]


    def _gltbPointToVector(self, x, y, width, height):
        "'project' x, y onto a hemi-sphere centered within width, height. "
        v = []
        v.append((2.0 * x - width) / width)
        v.append((height - 2.0 * y) / height)
        d = math.sqrt(v[0]**2 + v[1]**2)
        if d < 1.4:
            v.append(math.cos((math.pi / 2.0) * d))
        else:
            v.append(math.cos(math.pi / 2.0))
        a = 1.0 / math.sqrt(v[0]**2 + v[1]**2 + v[2]**2)
        return [a*x for x in v]

    def gltbStartMotion(self, x, y, button, time):

        assert(self.button != -1)

        self.tracking = True
        self.lasttime = time
        self.lastposition = self._gltbPointToVector(x, y, self.width, self.height)


    def gltbStopMotion(self, button, time):

        assert(self.button != -1)

        self.tracking = False

        self.animate = (time - self.lasttime < GLTB_TIME_EPSILON)


    def gltbAnimate(self):
        self.recalculateTransformationMatrix()
        glutPostRedisplay()


    def gltbInit(self, button):
        self.button = button
        self.angle = 0.0

        #/* put the identity in the trackball transform */
        glPushMatrix()
        glLoadIdentity()
        self.transform = glGetFloatv(GL_MODELVIEW_MATRIX)
        glPopMatrix()
        self.pan = self.transform
        
    def gltbMatrix(self):

        assert(self.button != -1)
        glTranslatef(*self.center)
        glMultMatrixf(self.transform)


    def gltbReshape(self, width, height):

        assert(self.button != -1)

        self.width  = width
        self.height = height


    def gltbMotion(self, x, y):
        
        assert(self.button != -1)
        if (self.tracking == False):
            return

        current_position = self._gltbPointToVector(x, y, self.width, self.height)

        ##  /* calculate the angle to rotate by (directly proportional to the
        ##     length of the mouse movement) */
        dx = current_position[0] - self.lastposition[0]
        dy = current_position[1] - self.lastposition[1]
        dz = current_position[2] - self.lastposition[2]
        self.angle = 90.0 * math.sqrt(dx**2 + dy**2 + dz**2)

        ##  /* calculate the axis of rotation (cross product) */
        self.axis[0] = self.lastposition[1] * current_position[2] - self.lastposition[2] * current_position[1]
        self.axis[1] = self.lastposition[2] * current_position[0] - self.lastposition[0] * current_position[2]
        self.axis[2] = self.lastposition[0] * current_position[1] - self.lastposition[1] * current_position[0]

        self.recalculateTransformationMatrix()
        ##  /* reset for next time */
        self.lasttime = glutGet(GLUT_ELAPSED_TIME)
        self.lastposition = current_position

    def recalculateTransformationMatrix(self):
        glPushMatrix()
        glLoadIdentity()
        glTranslatef(-self.center[0], -self.center[1], -self.center[2])
        glRotated(self.angle, self.axis[0], self.axis[1], self.axis[2])
        glTranslatef(*self.center)        
        glMultMatrixf(self.transform)
        self.transform = glGetFloatv(GL_MODELVIEW_MATRIX)
        glPopMatrix()

    def gltbZoom(self, x ,y, lastx, lasty):
        self.zoomFactor += (y - lasty)/1000.0
        if self.zoomFactor < 0.05:
            self.zoomFactor = 0.05; return
        elif self.zoomFactor > 3.0:
            self.zoomFactor = 3.0; return
        
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        gluPerspective(45.0*self.zoomFactor,  self.width/self.height, 1.0, 100.0)
        glMatrixMode(GL_MODELVIEW)
        
    def gltbPan(self, x ,y, lastx, lasty):
        scale	  = 0.02 # XXX
        delta = [scale * (x - lastx), scale * (lasty- y), 0.0]
        self.center= [a+b for (a,b) in zip(delta, self.center)]
ClusterViz-0.2/visualkmeans.py0000644000175000001440000004575310405130626016263 0ustar  maaskolausers#
#    visualkmeans.py - kmeans-clustering algorithms with visualization hooks
#
#    Copyright (C) 2003  Alexander Schliep
#    Copyright (C) 2005  Janne Grunau, Jonas Maaskola
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#

import Numeric
import RandomArray
import MLab

import copy, logging, math, pstats, random, string, sys, threading
import clusterdisplay

DEBUGOUTPUT = 0

logger = logging.getLogger("Clustering")

def initLogger():
    # Organize logging.
    logger = logging.getLogger("Clustering")
    hdlr = logging.StreamHandler()
    if not DEBUGOUTPUT:
        logger.setLevel(logging.INFO)
        formatter = logging.Formatter('%(message)s')
    else:
        logger.setLevel(logging.DEBUG)
        formatter = logging.Formatter('Clustering %(levelname)s %(message)s')
    hdlr.setFormatter(formatter)
    logger.addHandler(hdlr)

profiling = 0
eps = 0.001


def HammingDistance (v, w):
    return Numeric.innerproduct(v,v) + Numeric.innerproduct(w,w) - 2 * Numeric.innerproduct(v,w)


def Euclidean (v, w):
    x = v-w
    return math.sqrt(Numeric.innerproduct(x,x))


def OrderedPairs (input_list):
    result = []
    for i, v in enumerate(input_list):
        for w in input_list[i+1:]:
            result.append((v,w))
    return result


def AllPairs (L, M):
    return  [(x,y) for x in L for y in M]


def Entropy (probdist):
    """Calculates the Shannon entropy in nats.
    Expects a probability distriubtion as argument."""
    probdist = [v for v in probdist if v!=0.0]

    return -Numeric.sum(probdist * Numeric.log(probdist))




class Clustering(threading.Thread):
    def __init__(self, data, display, k, dist, algorithm, redraw_event, beta = None):
        self.display = display
        self.seqs = data
        self.algorithm = algorithm
        self.beta = beta
        self.end_flag=False
        self.thread_suspend=False
        self.sleep_time=0.0
        self.thread_sleep=False
        threading.Thread.__init__(self)
        # Default values
        self.k = k
        self.distanceFunction = dist

        #threading syncronizisation
        self.abortNOW = False
        self.redraw_event = redraw_event

    
        self.nrSeqs = len(self.seqs)
        self.responbilityFunction = None

        self.sqrtof2pi = math.sqrt(2*math.pi)
        self.dimensions = len(self.seqs[0])
        self.pi = Numeric.array([1.0/self.k]*self.k)
        self.sigma = Numeric.array([[.3]*self.dimensions]*self.k)

        self.printDetails = len(self.seqs) < 1.5e2
        logger.info("Details: "+str(self.printDetails))


    def run(self):

        #wait for the display coming ready
        self.redraw_event.wait()
        self.display.updateDisplay()
        self.redraw_event.wait()
        logger.debug("Clustering started.")

        if self.algorithm == "KMeans":
            self.computeKMeans(self.k)
            if self.printDetails and not self.abortNOW:
                self.display.enableHistory(self.singleKMeans)
                prettyPrint(range(len(self.seqs)), self)
                
        elif self.algorithm == "softKMeans":
            self.computeSoftKMeans(self.k, self.computeResposibilities)
            if not self.abortNOW:
                self.display.enableHistory(self.singleSoftKMeans)
                
        elif self.algorithm == "improvedSoftKMeans":
            self.computeSoftKMeans(self.k, self.computeGaussianResposibilities)
            if not self.abortNOW:
                self.display.enableHistory(self.singleSoftKMeans)

        logger.debug("Done.")


    def minimalRadii (self):
        # initialisation and minimun for cluster 0
        radii = Numeric.array ([self.distanceFunction (self.reps[0], self.reps[1])/4]*self.dimensions)
        #logger.info("distance cluster 0 vs. cluster 1: "+str(radii))
        self.sigma[0] = radii
        self.sigma[1] = radii
        for c in xrange(2, self.k):
            radii = Numeric.array ([self.distanceFunction (self.reps[0], self.reps[c])/4]*self.dimensions)
            #logger.info("distance cluster 0 vs. cluster "+str(c) + ":" + str(radii))
            if radii[0] < self.sigma[0][0]:
                self.sigma[0] = radii
            self.sigma[c] = radii

        #find minimum
        for c in xrange(1, self.k-1):
            for b in xrange(c+1, self.k):
                radii = Numeric.array ([self.distanceFunction (self.reps[c], self.reps[b])/4]*self.dimensions)
                #logger.info("distance cluster " + str(c) + " vs. cluster " + str(b) + ": " + str(radii))
                if radii[0] < self.sigma[c][0]:
                    self.sigma[c] = radii
                if radii[0] < self.sigma[b][0]:
                    self.sigma[b] = radii


    def computeKMeans (self, k):
        self.k = k
        self.entropyMax = Entropy([(1.0/k)]*k)

        # --------- Compute an initial partition ----------
        # Here: pick k different seqs 
        initial = self.selectkDistinctSeqs(k)
        #logger.info("# Initially selected strings" + str(initial))

        self.reps = []
        self.display.clearClusters(k)
        for i in initial:
            self.reps.append(copy.copy(self.seqs[i]))
            
        logger.info("Cluster centers:")
        logger.info(str(self.reps))
        logger.info("Standard deviations:")
        for line in str(self.sigma).split("\n"): logger.info(line)

        # ------- compute minimal radii -------
        self.minimalRadii()
        logger.info("Standard deviations:")
        for line in str(self.sigma).split("\n"): logger.info(line)

        self.clustercenters = [[]] * k
        self.data = [None] * self.nrSeqs

        # --------- Iterate -------------------------------
        goOn = 1
        while goOn and not self.abortNOW:
            self.redraw_event.wait()
            goOn = self.singleKMeans (k)
            

    def singleKMeans (self, k, reps=None, radius=None, waittime=None):

        if reps != None:
            self.reps = reps
            self.sigma = radius
            self.clustercenters = [[]] * k
            self.data = [None] * self.nrSeqs
            
        # -------- Assign sequences to clusters -------
        assignment_changed = 0
        
        for c in xrange(k):
            self.clustercenters[c] = []
            
        for i in xrange(self.nrSeqs):
            (c, entropy) = self.findClosest(i)

            if self.data[i] != c:
                assignment_changed = 1
            #hook function for updating cluster assignment of data point i
            self.display.changeAssignment(i, c, entropy)

            self.data[i] = c
            self.clustercenters[c].append(i)
            
        self.display.regenData = True
        logger.debug("Data points per clusters: " + str(self.clustercenters))
        self.redraw_event.wait(waittime)
        #ugly check to abort computation
        if self.abortNOW: return

        # -------- Display clusters before updating ---
        for c in xrange(k):
            #hook function for cluster centroid display
            self.display.updateCluster(c, self.reps[c], self.sigma[c])
            self.redraw_event.wait(waittime)
            #ugly check to abort computation
            if self.abortNOW: return 0

        # if the update only the display we are finished
        if reps != None:
            return 0

        # -------- recompute reps -------
        for c in xrange(k):
          
            self.redraw_event.wait()
            #ugly check to abort computation
            if self.abortNOW: return 0

            if len(self.clustercenters[c]) > 0:
                new_rep = copy.copy(self.seqs[self.clustercenters[c][0]])
                for i in xrange(1,len(self.clustercenters[c])):
                    new_rep += self.seqs[self.clustercenters[c][i]]

                new_rep = new_rep * (1.0 / len(self.clustercenters[c]))
                self.reps[c] = new_rep

        # -------- compute minimal radii -------
        self.minimalRadii()
        logger.info("Standard deviations:")
        for line in (str(self.sigma)).split("\n"): logger.info(line)
        

        return assignment_changed
                

    def computeSoftKMeans(self, k, responbilityFunction):
        self.k = k
        self.entropyMax = Entropy([(1.0/k)]*k)
        
        self.responbilityFunction = responbilityFunction

        # --------- Compute an initial partition ----------
        # Here: pick k different seqs 
        initial = self.selectkDistinctSeqs(k)
        #logger.info("# Initially selected strings " + str(initial))

        self.reps = []
        self.display.clearClusters(k)
        for i in initial:
            self.reps.append(copy.copy(self.seqs[i]))

        #logger.info("reps" + str(self.reps))
        self.data = [Numeric.array([0.0]*k)] * self.nrSeqs

        # --------- Iterate -------------------------------
        goOn = 1
        while goOn and not self.abortNOW:
            self.redraw_event.wait()
            goOn = self.singleSoftKMeans(k)


    def singleSoftKMeans(self, k, reps=None, sigma=None, waittime=None):

            if reps != None:
              self.reps = reps
              self.sigma = sigma
              self.data = [Numeric.array([0.0]*k)] * self.nrSeqs
            
            # -------- Assign sequences to clusters -------
            assignment_changed = 0

            self.clustercenters = Numeric.array([0.0] * k)

            for i in xrange(self.nrSeqs):
                (respons, c, entropy) = self.responbilityFunction(i)

                if self.distanceFunction(self.data[i], respons) > eps:
                    assignment_changed = 1
                #hook function for updating cluster assignment of data point i
                self.display.changeAssignment(i, c, entropy)

                self.data[i]         = respons
                self.clustercenters += respons
                
            self.display.regenData = True
            logger.debug("Data points per clusters: " + str(self.clustercenters))
            self.redraw_event.wait(waittime)
            #ugly check to abort computation
            if self.abortNOW: return 0


            # -------- Display clusters before updating ---
            for c in xrange(k):
                #hook function for cluster centroid display
                self.display.updateCluster(c, self.reps[c], self.sigma[c])
                self.redraw_event.wait(waittime)
                #ugly check to abort computation
                if self.abortNOW: return 0

            # if the update only the display we are finished
            if reps != None:
                return 0

            # -------- recompute pis -------
            self.pi = self.clustercenters / Numeric.sum(self.clustercenters)
            logger.info("Data distribution over clusters: "+str(self.pi))
            # -------- compute entropy -----
            entropy = Entropy(self.pi)
            logger.info("Entropy of data distribution over clusters = " + str(entropy))
            self.display.addEntropy(entropy)
            # -------- recompute reps -------
            for c in xrange(k):

                self.redraw_event.wait()
                #ugly check to abort computation
                if self.abortNOW: return 0
              
                new_rep = copy.copy([0]*self.dimensions)
                for i in xrange(self.nrSeqs):
                    new_rep += self.seqs[i] * self.data[i][c]

                if self.clustercenters[c] > 0:
                    self.reps[c] = new_rep * (1.0 / self.clustercenters[c])

            # -------- recompute sigmas -------
                    d = Numeric.array([0.0] * self.dimensions)
#                     logger.info(str(self.data[0][c])+" "+str(self.seqs[0])+" "+ str(self.reps[c]))
                    for i in xrange(self.nrSeqs):
                        d += self.data[i][c] * Numeric.power(self.seqs[i] - self.reps[c],2)
                    self.sigma[c] = Numeric.sqrt(d  / (self.dimensions * self.clustercenters[c]))
#                    logger.info("d: "+str(d)+ " sigma[c]: " + str(self.sigma[c]) +" "+ str(self.dimensions) +" "+ str(self.clustercenters))
                else:
                  logger.info("self.data["+str(c)+"] ! >0.")

            logger.info("Standard deviations:")
            for line in str(self.sigma).split("\n"): logger.info(line)

            return assignment_changed


    def findClosest (self, i):
        min_d = 99999.9
        d = Numeric.array([0.0] * self.k)
        result = -1
        for r in xrange(self.k):
            d[r] = self.distanceFunction(self.seqs[i], self.reps[r])
            if d[r] < min_d:
                min_d = d[r]
                result = r
        # scale the entropy using a cutoff value
        cutoff = 0.7
        scale_factor = 1.0 / (1.0 - cutoff)
        return (result, max(0.0, scale_factor * 
                            (Entropy(d / sum(d)) / self.entropyMax - cutoff) ))


    def computeResposibilities(self,i):
        result = Numeric.array([0.0] * self.k)
        sum = 0.0
        for r in xrange(self.k):
            d = math.exp(-self.beta * 
                         self.distanceFunction(self.seqs[i], self.reps[r]))
            result[r] = d
            sum += d

        try:
            result = result/sum
        except OverflowError:
            logger.error("Kaboum! Soft k-means algorithm just blew up!")
            logger.error("This happens especially in high-dimensional problems when individual data")
            logger.error("samples have a relatively high distance to all clusters in comparison with")
            logger.error("those lying closer to the clusters that have a higher responsibility.")
            logger.error("Kindly restart the algorithm or consider using hard k-means.")
            sys.exit(1)
        return (result,
                Numeric.argmax(result), 
                Entropy(result) / self.entropyMax)


    def computeGaussianResposibilities(self,i):
        result = Numeric.array([0.0] * self.k)
        sum = 0.0
        for r in xrange(len(self.reps)):
            #if the variance of a cluster is zero
            #it is only responsibility for the cluster center
            try:
                d = (self.pi[r] / Numeric.multiply.reduce(self.sqrtof2pi * self.sigma[r])) \
                    * math.exp(-1 * Numeric.add.reduce( Numeric.power(self.reps[r]-self.seqs[i], 2)
                                                        / (2*Numeric.power(self.sigma[r],2))))
            except:
                logger.warn("BAD. At least one cluster has zero variance.")
                logger.warn("You may choose a smaller number of clusters or")
                logger.warn("simply repeat the clustering and hope for better luck.")
                sys.exit(1)

            result[r] = d
            sum += d

        try:
            result = result/sum
        except OverflowError:
            logger.error("Kaboum! The mixture models algorithm just blew up!")
            logger.error("This happens especially in high-dimensional problems when individual data")
            logger.error("samples have a relatively high distance to all clusters in comparison with")
            logger.error("those lying closer to the clusters that have a higher responsibility.")
            logger.error("Kindly restart the algorithm or consider using hard k-means.")
            sys.exit(1)

        argmax = Numeric.argmax(result)
        #logger.info( "result: %s   argmax: %s" result, argmax)
        return (result,
                argmax,
                Entropy(result) / self.entropyMax)


    def matches(self,i,seq_ids):
        for j in seq_ids:
            if self.distanceFunction(self.seqs[i],self.seqs[j]) < eps:
                return True
        return False


    def selectkDistinctSeqs(self,k):
        """ Try to select k distinct sequences randomly.
            Return a list of their indices """

        seq_ids = range(self.nrSeqs) 
        result = []

        while len(result) < k and len(seq_ids) > 0:
            i = random.choice(seq_ids)
            if not self.matches(i,result):
                result.append(i)
            seq_ids.remove(i)
            
        return result


    def nrClusters(self):
        return len(self.clustercenters)



def sortByLen(x,y):
    if len(x) < len(y):
        return 1
    elif len(x) == len(y):
        return 0
    else:
        return -1


def stat(a):
    na = Numeric.array(a)
    return (MLab.mean(na), MLab.std(na), min(na), max(na))


def HammingDistanceStatistics(clustering, clusters):
    between_hds_list = [] # list of between cluster hamming distances
    within_hds_list = []  # list of all within cluster hamming distances for all clusters
    within_hds_stat = {}  # for each cluster this holds the within-variation stat()

    for i, ci in enumerate(clusters):
        for cj in clusters[i+1:]:
            for (s,t) in AllPairs(ci,cj):
                between_hds_list.append(HammingDistance(clustering.data[s], clustering.data[t]))

        hds_list = []
        if len(ci) > 2:
            for (s,t) in OrderedPairs(ci):
                h = HammingDistance(clustering.data[s], clustering.data[t])
                hds_list.append(h)
                within_hds_list.append(h)

            within_hds_stat[i] = stat(hds_list)
        else:
            within_hds_stat[i] = (None, None, None, None)

    return (stat(within_hds_list), stat(between_hds_list), within_hds_stat)
    

def comp_wdelta(within, between):
    return (between[0] - within[0]) / math.sqrt(between[1] + within[1])


def prettyPrint(ids, clustering):
    logger.info("# "+ str(clustering.nrClusters())+ " clusters of sizes")
    logger.info( string.join(map(str,Numeric.sort(map(len,clustering.clustercenters))),' '))

    # print all clusters by size
    clusters = copy.copy(clustering.clustercenters)
    clusters.sort(sortByLen)

    (within, between, within_hds_stat) = HammingDistanceStatistics(clustering, clusters)        

    wdelta = comp_wdelta(within, between)
    logger.info("# pair-wise hamming distances (weighted delta=%1.2f)" % wdelta)
    logger.info("#     between clusters avg=%1.2f (+/-%1.2f) min=%1.1f max=%1.1f" % between)
    logger.info("#      within clusters avg=%1.2f (+/-%1.2f) min=%1.1f max=%1.1f" % within)

    for i, cluster in enumerate(clusters):
        logger.info( "#----------------------------------------------------------------")
        logger.info("# cluster"+str( i + 1) + " size=%d" % len(cluster))

        if len(cluster) > 2:
            logger.info("#      within cluster avg=%1.2f (+/-%1.2f) min=%1.1f max=%1.1f" % \
                  within_hds_stat[i])

        #for s in cluster:
            #logger.info(str(ids[s]))
ClusterViz-0.2/guihelp.py0000644000175000001440000000326410400367054015207 0ustar  maaskolausers#
#    guihelp.py - GUI help text
#
#    Copyright (C) 2005  Jonas Maaskola
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#

gui_help_text = """Visual kmeans clustering


This is a software to visualize the clustering process using the family of
kmeans algorithms.

The following commands are available in the GUI:

Commands
--------
h        Toggle display this help information
q / ESC  Quit program

f        Switch to fullscreen display
w        Switch to a windowed display

p        Pause the clustering thread
r        Restart the clustering thread

b        Go back one step in the clustering process history
n        Go forward one step in the clustering process history

j        Toggle the display of the trajectories
d        Toggle the display of the data
c        Toggle the display of the cluster represntations


Mouse control
-------------
LMB-click                       Rotate
MMB-click / Shift-LMB-click     Pan
RMB-click                       Zoom

Here LMB means left mouse button; MMB, RMB analogous."""
ClusterViz-0.2/PKG-INFO0000644000175000001440000000105210405136430014263 0ustar  maaskolausersMetadata-Version: 1.0
Name: ClusterViz
Version: 0.2
Summary: Clustering visualization
Home-page: http://clusterviz.sourceforge.net/
Author: Jonas Maaskola
Author-email: nayme@users.sourceforge.net
License: GNU General Public License (GPL)
Description: Performs a clustering algorithm and visualizes the process.
        Available algorithms are: hard k-means, soft k-means and mixture models.
        Visualization uses OpenGL. Data is presented in a simple one-sample-per-
        line format where the components are space separated.
Platform: UNKNOWN
ClusterViz-0.2/scripts/0000755000175000001440000000000010405136430014657 5ustar  maaskolausersClusterViz-0.2/scripts/generateSignals4D.py0000755000175000001440000000271410400367054020546 0ustar  maaskolausers#!/usr/bin/python
# Generate some data points

import sys
import random
from optparse import OptionParser

NDIMS = 4
defCenter = (0.0, 0.0, 0.0, 1.0)
usage = sys.argv[0]+""" nrSamples
Generate nrSamples """+str(NDIMS)+"""-dimensional signals from a number of weighted Gaussian distributions."""

if __name__ == "__main__":
  parser = OptionParser(usage)
  parser.add_option("-g", "--gauss", metavar="MU1 MU2 MU3 SDEV1 SDEV2 SDEV3 W", type="float", nargs=NDIMS*2+1, action="append",
    help="add a gaussion signal generator with parameter MU1 MU2 MU3 and SDEV1 SDEV2 SDEV3."
    "From this gaussian will be sampled using a weight of W.")

  (cloptions, args) = parser.parse_args()
#   print args, cloptions

  if len(args) < 1:
    print "Please provide the number of signals to be generated."
    sys.exit(1)

  if cloptions.gauss is None:
    print "Please give at least one gaussian signal generator."
    sys.exit(1)
	    
  if len (cloptions.gauss) == 0:
    cloptions.gauss = [defCenter]

  cnt = int(args[0])

  while (cnt > 0):
    sample = []
    cnt -= 1
    r = random.random()
#     print "r =",r
    select = 0
    while (r > 0):
      r -= cloptions.gauss[select][NDIMS*2]
#       print "r =",r
      select += 1
    select -= 1
#     print "select",select
    for i in range(NDIMS):
      sample.append(random.gauss(cloptions.gauss[select][i],cloptions.gauss[select][i+NDIMS]))
#       print cloptions.gauss[select]

    for term in sample:
      print term,
    print
ClusterViz-0.2/scripts/clusterviz0000644000175000001440000001422510400367054017023 0ustar  maaskolausers#!/usr/bin/python
#
#    clusterviz.py - visualization for clustering processes
#
#    Copyright (C) 2005  Jonas Maaskola
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
# ------------------------------------------------------------------------------
#
# This script is the front end for the ClusterViz package.
# It is intended to be the prefered way of using the functionality included.
#
# Just run it with the "-h" option to get intial help on how to use it.

from optparse import OptionParser
import os, random, sys, threading
import Numeric
from ClusterViz import visualkmeans, clusterdisplay, auxiliary

description = """This program clusters data and visualizes the process.
It uses hard k-means clustering when no other method is specified. Alternatives
are soft k-means or mixture models.
If the file argument is '-' data is read from standard input.
If the dimensionality of the data is greater than three the default is to 
display the projection onto the first three. There are two mutually exclusive
options to control the projection more fine-grained. One allows to select
three dimensions that should be respected in the projection. The other is to
define a linear transformation matrix in a seperate file and use that to project
the data.
Please mind that help is available in the GUI via 'h'."""

if __name__ == "__main__":
    random.seed()
    visualkmeans.initLogger()

    # Default values
    k = 3
    dist = visualkmeans.Euclidean
    algorithm = "KMeans"

    parser = OptionParser(description=description,
                          usage="%prog [options] file",
                          version="Visualization for kmeans and similar 0.2")

    parser.add_option("-s", "--soft", action="store",dest="beta", metavar="BETA", default=-10.0, type='float', help="Perform soft k-means clustering instead of hard k-means clustering on the data. Use as beta-parameter BETA.")
    parser.add_option("-m", "--mixture", action="store_true",dest="mixture", default=False, help="Perform mixture model clustering instead of k-means clustering on the data.")
    parser.add_option("-k", action="store", dest="k", metavar="K", default=k, help="Use K clusters. Default = %s"%k)
    parser.add_option("-t", "--transform", dest="transform", metavar="FILE", help="Read transformation matrix from FILE and use that to project the data to three dimensions.")
    parser.add_option("-d", "--dimensions", dest="dims", metavar="DIM0 DIM1 DIM2", type="int", nargs=3, help="Enumerate three dimensions to display. To select only one or two dimensions fill up with negative indices.")
    (cloptions, args) = parser.parse_args()

    if (cloptions.beta >0.0 and cloptions.mixture):
        print "Please select only one clustering algorithm."
        sys.exit(2)
    elif cloptions.beta > 0.0:
        algorithm = "softKMeans"
    elif cloptions.mixture:
        algorithm = "improvedSoftKMeans"
    k = int(cloptions.k)
    beta = cloptions.beta
    transform = cloptions.transform
    dims = cloptions.dims

    if len(args) > 0:
        datafile = args[0]
        if datafile != "-":
            auxiliary.fail_if_nonexistent(datafile)
	if len(args) > 1:
	    if len(args) > 2: nr = "s"
	    else: nr = ""
	    print "Unrecognized argument%s %s." % (nr, str(args[1:])[1:][:-1])
	    sys.exit(-1)
    else:
        print "Please specify path to datafile or '-' to read from standard " \
            "input."
        sys.exit(-1)
    data = auxiliary.read_data(datafile)
 
    data_dimension = Numeric.size(data[0])
    # Determine projection matrix
    if transform is not None:
        if dims is not None:
            print "Please mind that the options -t and -d (--transform and " \
                "--dimensions) are mutually exclusive."
            sys.exit(-2)
        auxiliary.fail_if_nonexistent(transform)
        transformation_matrix = auxiliary.read_matrix(transform)
    elif dims is not None:
        transformation_matrix = Numeric.zeros([data_dimension,3])
        for i in range(3):
            if dims[i] >= 0:
                transformation_matrix[dims[i]][i] = 1.0
    else:
        if data_dimension > 3:
            transformation_matrix = Numeric.zeros([data_dimension,3])
            for i in range(3):
                transformation_matrix[i][i] = 1.0
        else:
            transformation_matrix = None

    if transformation_matrix is not None:
        rows,cols = Numeric.shape(transformation_matrix)
        if not (data_dimension == rows and cols == 3):
            print "Dimensions %ix%i of transformation matrix do not match data." \
             % (rows, cols)
            print "They should be %ix3." % data_dimension
            sys.exit(-2)

    # Construct window title
    title = ""
    if algorithm == "KMeans":
      title += "K-means "
    elif algorithm == "softKMeans":
      title += "Soft K-means "
    elif algorithm == "improvedSoftKMeans":
      title += "Mixture models of axiparallel gaussians "
    title += "clustering for "+datafile

    # Create event to synchronize computation and display threads
    redraw_ev = threading.Event()
    redraw_ev.clear()
    
    # Create display thread
    display = clusterdisplay.clusterDisplay(data, k, transformation_matrix,
        redraw_ev, 800, 600, title)

    # Create and start computation thread
    clusterComputation = visualkmeans.Clustering(data, display, k, dist,
        algorithm, redraw_ev, beta)
    clusterComputation.start()

    # Set the pointer to the clustering thread
    display.clusteringThread = clusterComputation

    # Perform UI & visualization loop
    display.mainLoop()
ClusterViz-0.2/scripts/generateSignals3D.py0000755000175000001440000000270710400367054020547 0ustar  maaskolausers#!/usr/bin/python
# Generate some data points

import sys
import random
from optparse import OptionParser

NDIMS = 3
defCenter = (0.0, 0.0, 0.0, 1.0)
usage = sys.argv[0]+""" nrSamples
Generate nrSamples """+str(NDIMS)+"""-dimensional signals from a number of weighted Gaussian distributions."""

if __name__ == "__main__":
  parser = OptionParser(usage)
  parser.add_option("-g", "--gauss", metavar="MU1 MU2 MU3 SDEV1 SDEV2 SDEV3 W", type="float", nargs=NDIMS*2+1, action="append",
    help="add a gaussion signal generator with parameter MU1 MU2 MU3 and SDEV1 SDEV2 SDEV3."
    "From this gaussian will be sampled using a weight of W.")

  (cloptions, args) = parser.parse_args()
#   print args, cloptions

  if len(args) < 1:
    print "Please provide the number of signals to be generated."
    sys.exit(1)

  if cloptions.gauss is None:
    print "Please give at least one gaussian signal generator."
    sys.exit(1)

  if len (cloptions.gauss) == 0:
    cloptions.gauss = [defCenter]

  cnt = int(args[0])

  while (cnt > 0):
    sample = []
    cnt -= 1
    r = random.random()
#     print "r =",r
    select = 0
    while (r > 0):
      r -= cloptions.gauss[select][NDIMS*2]
#       print "r =",r
      select += 1
    select -= 1
#     print "select",select
    for i in range(NDIMS):
      sample.append(random.gauss(cloptions.gauss[select][i],cloptions.gauss[select][i+NDIMS]))
#       print cloptions.gauss[select]

    for term in sample:
      print term,
    print
ClusterViz-0.2/COPYING0000644000175000001440000004311010400367054014225 0ustar  maaskolausers		    GNU GENERAL PUBLIC LICENSE
		       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

			    Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

			    NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

		     END OF TERMS AND CONDITIONS

	    How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

    Gnomovision version 69, Copyright (C) year  name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.
ClusterViz-0.2/README0000644000175000001440000000640010405134402014045 0ustar  maaskolausersClusterViz - Visual kmeans clustering
===================================

This is a software to visualize the clustering process using the family of
k-means algorithms. The program is free software under the GNU General Public
License (GPL). It is hosted on Sourceforge. The homepage is
http://clusterviz.sourceforge.net/
and it can be downloaded from
http://sourceforge.net/projects/clusterviz/


Dependencies
============

Clusterviz depends on the following packages:

Numeric      http://numeric.scipy.org/
PyOpenGL     http://pyopengl.sourceforge.net/

Additionally it can make use of an existing installation of the statistics
software R to make plots. Then you also will need

RPy          http://rpy.sourceforge.net/

Installation
============

Installation follows the standard Python package management principles: Just run

python setup.py install

to build and install the package. Note that you might have to perform this with
a user with sufficient rights. This could mean that you have to be root if
installing under UNIX.


Running the program
===================

The program is called

clusterviz


Just run this Python script with the data file to work on as argument to the
file option:

clusterviz FILE


To get information about how to use it you can issue:

clusterviz -h


To use another algorithm than the default and fast hard k-means algorithm use
one of these commands (which are documented in the above help output).

Soft k-means with beta = 30:      clusterviz -s 30 test.dat
Mixture models:                   clusterviz -m test.dat


Data file format
================

The data are presented to ClusterViz in a flat-file format. Per line one data
sample is expected whose components are white-space separated. Earlier versions
of ClusterViz supported only three-dimensional data. This restriction has now
been lifted. X-dimensional data can be projected down to three dimensions by
just using the first three and disregarding the rest for displaying. Other
possibilities are to determine via a command line option which dimensions to use
in this way or to give a linear transformation matrix that is applied for the
display (see the --help option for the syntax). Note that the clustering process
itself works on the non-transformed data and only the display is result of the
projection.
Example data sets to try ClusterViz out can be downloaded from the project's
Sourceforge file area under
http://sourceforge.net/project/showfiles.php?group_id=154324

GUI controls
============

There are a number of commands available in the GUI. To see them just hit 'h'
while the GUI is running.

Commands
--------
h        Toggle display this help information
q / ESC  Quit program

f        Switch to fullscreen display
w        Switch to a windowed display

p        Pause the clustering thread
r        Restart the clustering thread

b        Go back one step in the clustering process history
n        Go forward one step in the clustering process history

j        Toggle the display of the trajectories
d        Toggle the display of the data
c        Toggle the display of the cluster represntations


Mouse control
-------------
LMB-click                       Rotate
MMB-click / Shift-LMB-click     Pan
RMB-click                       Zoom

Here LMB means left mouse button; MMB, RMB analogous.
ClusterViz-0.2/auxiliary.py0000644000175000001440000000351510400367054015560 0ustar  maaskolausers#
#    auxiliary.py - auxiliary routines for ClusterViz package
#
#    Copyright (C) 2005 Jonas Maaskola
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
import Numeric, os, string, sys

def read_data(fileName):

    try:
        if fileName == "-":
            file = sys.stdin
        else:
            file = open(fileName,'r')
        lines = file.readlines()
        file.close()
    
        data = []
        for l in lines:
            #logger.info(str(string.split(l)))
            data.append(Numeric.array(map(float,string.split(l))))
    
        return data
    except:
        return []

def fail_if_nonexistent(path, msg = None):

    try:
        os.stat(path)
    except:
        print "%s not found. Please check path validity." % path
        if msg is not None:
            print msg
        sys.exit(2)

def read_matrix(path):
    try:
        file = open(path,'r')
        lines = file.readlines()
        file.close()
        
        matrix = Numeric.empty([len(lines), len(lines[0].split())])
        for i in range(len(lines)):
            matrix[i] = [float(x) for x in lines[i].split()]
        return matrix
    except:
        return Numeric.empty(0)
ClusterViz-0.2/setup.py0000644000175000001440000000142410405136364014711 0ustar  maaskolausersfrom distutils.core import setup
setup(name='ClusterViz',
      version='0.2',
      description='Clustering visualization',
      long_description="""Performs a clustering algorithm and visualizes the process.
      Available algorithms are: hard k-means, soft k-means and mixture models.
      Visualization uses OpenGL. Data is presented in a simple one-sample-per-
      line format where the components are space separated.""",
      author='Jonas Maaskola',
      author_email='nayme@users.sourceforge.net',
      url='http://clusterviz.sourceforge.net/',
      license='GNU General Public License (GPL)',
      scripts=['scripts/clusterviz','scripts/generateSignals3D.py','scripts/generateSignals4D.py'],
      package_dir={'ClusterViz': ''},
      packages=['ClusterViz']
      )
ClusterViz-0.2/__init__.py0000644000175000001440000000005210400367054015301 0ustar  maaskolausersimport visualkmeans
import clusterdisplay
ClusterViz-0.2/AUTHORS0000644000175000001440000000021010400367054014234 0ustar  maaskolausersJonas Maaskola <nayme@users.sourceforge.net>
Janne Grunau <grunau@molgen.mpg.de>
Karsten Weinert <KarstenWeinert@users.sourceforge.net>