# # -*- coding: utf-8 -*- # # @Time : 2019/3/7 19:11 # # @Author : SilverMaple # # @Site : https://github.com/SilverMaple # # @File : algorithmView.py # from OpenGL.GL import * from OpenGL.GLUT import * from OpenGL.GLU import * import math import numpy as np from copy import deepcopy # epochs = 34 # n = 7 # outer_radius = .3 # inner_radius = outer_radius * 2 * np.pi / n # theta = np.linspace(0, 2 * np.pi, n + 1)[:-1] # length = np.random.rand(n) class OpenGLText(): # bitmap_fonts = [ # GLUT_BITMAP_9_BY_15, # GLUT_BITMAP_8_BY_13, # GLUT_BITMAP_TIMES_ROMAN_10, # GLUT_BITMAP_TIMES_ROMAN_24, # GLUT_BITMAP_HELVETICA_10, # GLUT_BITMAP_HELVETICA_12, # GLUT_BITMAP_HELVETICA_18] def print_bitmap_string(self, fonts, s): for c in s: glutBitmapCharacter(fonts, * s) def TextOut(self, x, y, s): glRasterPos2f(x, y) self.print_bitmap_string(self.bitmap_fonts[4], s) class Camera: origin = [0.0, 0.0, 0.0] length = 100. yangle = 0. zangle = 0. scaleFactor = 1.0 __bthree = False def __init__(self): self.mouseLocation = [0.0, 0.0] self.offest = .1 self.zangle = 0. if not self.__bthree else math.pi def setThirdPersonPerspective(self, value): self.__bthree = value self.zangle = self.zangle + math.pi self.yangle = -self.yangle def eye(self): return self.origin if not self.__bthree else self.direction() def target(self): return self.origin if self.__bthree else self.direction() def direction(self): if self.zangle > math.pi * 2.0: self.zangle = self.zangle - math.pi * 2.0 elif self.zangle < 0.: self.zangle = self.zangle + math.pi * 2.0 length = 1. if not self.__bthree else self.length if 0. else 1. xy = math.cos(self.yangle) * length x = self.origin[0] + xy * math.sin(self.zangle) y = self.origin[1] + length * math.sin(self.yangle) z = self.origin[2] + xy * math.cos(self.zangle) return [x, y, z] def move(self, x, y, z): sinz, cosz = math.sin(self.zangle), math.cos(self.zangle) xstep, zstep = x * cosz + z * sinz, z * cosz - x * sinz if self.__bthree: xstep = -xstep zstep = -zstep self.origin = [self.origin[0] + xstep, self.origin[1] + y, self.origin[2] + zstep] def rotate(self, z, y): self.zangle, self.yangle = self.zangle - z, self.yangle + y if not self.__bthree else -y def scale(self, step): self.scaleFactor += step if self.scaleFactor <= 0: self.scaleFactor = .01 def setLookat(self): ve, vt = self.eye(), self.target() # print ve,vt glLoadIdentity() gluLookAt(ve[0], ve[1], ve[2], vt[0], vt[1], vt[2], 0.0, 1.0, 0.0) def keypress(self, key, x, y): key = key.decode('utf-8') if key in ('w', 'W'): self.move(0., 0., 1 * self.offest) if key in ('s', 'S'): self.move(0., 0., -1 * self.offest) if key in ('a', 'A'): self.move(1 * self.offest, 0., 0.) if key in ('d', 'D'): self.move(-1 * self.offest, 0., 0.) if key in ('q', 'Q'): self.move(0., 1 * self.offest, 0.) if key in ('e', 'E'): self.move(0., -1 * self.offest, 0.) if key in ('z', 'Z'): self.scale(self.offest) if key in ('x', 'X'): self.scale(-self.offest) if key in ('v', 'V'): # this.__bthree = not this.__bthree self.setThirdPersonPerspective(not self.__bthree) if key == GLUT_KEY_UP: self.offest = self.offest + 0.1 if key == GLUT_KEY_DOWN: self.offest = self.offest - 0.1 def mouse(self, x, y): rx = (x - self.mouseLocation[0]) * self.offest * 0.1 ry = (y - self.mouseLocation[1]) * self.offest * -0.1 self.rotate(rx, ry) self.mouseLocation = [x, y] def mouseFunc(self, button, mode, x, y): if button == GLUT_RIGHT_BUTTON: self.mouseLocation = [x, y] def mouseWheelFunc(self, ): pass class OpenGLView(): camera = Camera() MUTUAL_INFORMATION_FILE = '数据集/karate/mutualInformation.txt' def drawRandom(self): n, epochs, stacks, outer_radius, inner_radius = self.n, self.epochs, self.stacks, self.outer_radius, self.inner_radius theta, length = self.theta, self.length for e in range(epochs): glColor3f(0.0, 0.0, 1.0) glTranslate(0, 0, e/epochs-.5) for i in range(n): glTranslatef(np.cos(theta[i]-np.pi/2) * outer_radius, np.sin(theta[i]-np.pi/2) * outer_radius, 0.0) glRotatef(90, np.cos(theta[i]), np.sin(theta[i]), 0) quadratic = gluNewQuadric() gluCylinder(quadratic, inner_radius, inner_radius, .1+length[i], stacks, stacks) # draw lateral of the cylinder # gluCylinder(quadratic, inner_radius, inner_radius, .1+length[i], stacks, stacks) # draw lateral of the cylinder gluDisk(quadratic, 0, inner_radius, stacks, stacks) # draw top and bottom glRotatef(-90, np.cos(theta[i]), np.sin(theta[i]), 0) glTranslate(-np.cos(theta[i]-np.pi/2) * outer_radius, -np.sin(theta[i]-np.pi/2) * outer_radius, 0.0) glColor3f(0.0, 1.0, 0.0) glutSolidTorus(inner_radius+.02, outer_radius, stacks, stacks) glTranslate(0, 0, -e / epochs+.5) def drawStatic(self): stacks, pointCountRecord, epochs, n, outer_radius, inner_radius, theta, length, colors = self.getData() for ei, e in enumerate(pointCountRecord): glTranslate(0, 0, ei / epochs - .5) for i in range(n): ci = e[str(i+1)][0] l = e[str(i+1)][1] glColor3f(colors[ci][0], colors[ci][1], colors[ci][2]) glTranslatef(np.cos(theta[i]-np.pi/2) * outer_radius, np.sin(theta[i]-np.pi/2) * outer_radius, 0.0) glRotatef(90, np.cos(theta[i]), np.sin(theta[i]), 0) quadratic = gluNewQuadric() gluCylinder(quadratic, inner_radius, inner_radius, .1+l/epochs, stacks, stacks) # draw lateral of the cylinder gluDisk(quadratic, 0, inner_radius, stacks, stacks) # draw top and bottom glRotatef(-90, np.cos(theta[i]), np.sin(theta[i]), 0) glTranslate(-np.cos(theta[i]-np.pi/2) * outer_radius, -np.sin(theta[i]-np.pi/2) * outer_radius, 0.0) glColor3f(0.0, 1.0, 0.0) glutSolidTorus(inner_radius+.02, outer_radius, stacks, stacks) glTranslate(0, 0, -ei / epochs + .5) def drawDynamic(self): stacks, pointCountRecord, epochs, n, outer_radius, inner_radius, theta, length, colors = self.getData() self.index += 1 for ei, e in enumerate(pointCountRecord[:(int(self.index / self.timeSpan) + 1) % epochs]): glTranslate(0, 0, ei / epochs - .5) for i in range(n): ci = e[str(i+1)][0] pl = e[str(i+1)][1] glColor3f(colors[ci][0], colors[ci][1], colors[ci][2]) glTranslatef(np.cos(theta[i]-np.pi/2) * outer_radius, np.sin(theta[i]-np.pi/2) * outer_radius, 0.0) glRotatef(90, np.cos(theta[i]), np.sin(theta[i]), 0) quadratic = gluNewQuadric() gluCylinder(quadratic, inner_radius, inner_radius, .1+pl/epochs, stacks, stacks) # draw lateral of the cylinder gluDisk(quadratic, 0, inner_radius, stacks, stacks) # draw top and bottom glRotatef(-90, np.cos(theta[i]), np.sin(theta[i]), 0) glTranslate(-np.cos(theta[i]-np.pi/2) * outer_radius, -np.sin(theta[i]-np.pi/2) * outer_radius, 0.0) glColor3f(0.0, 1.0, 0.0) glutSolidTorus(inner_radius+.02, outer_radius, stacks, stacks) glTranslate(0, 0, -ei / epochs + .5) def drawFunc(self): # glRotatef(0.1, 0, 5, 0) # (角度,x,y,z) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glMatrixMode(GL_MODELVIEW) self.camera.setLookat() glScalef(self.camera.scaleFactor, self.camera.scaleFactor, self.camera.scaleFactor) # self.drawRandom() # self.drawStatic() self.drawDynamic() glBegin(GL_LINES) glColor3f(1.0, 0.0, 0.0) glVertex3f(0, 0, 0) glVertex3f(0, 0, 2) glColor3f(0.0, 1.0, 0.0) glVertex3f(0, 0, 0) glVertex3f(2, 0, 0) glColor3f(0.0, 0.0, 1.0) glVertex3f(0, 0, 0) glVertex3f(0, 2, 0) glEnd() glFlush() glutSwapBuffers() def reshapeFunc(self, Width, Height): glViewport(0, 0, Width, Height) glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective(45.0, float(Width)/float(Height), 0.1, 100.0) glMatrixMode(GL_MODELVIEW) def openView(self): # 使用glut初始化OpenGL glutInit() # 显示模式:GLUT_SINGLE无缓冲直接显示|GLUT_RGBA采用RGB(A非alpha) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH) # 窗口位置及大小-生成 glutInitWindowPosition(0, 0) glutInitWindowSize(400, 400) w = glutCreateWindow(b"Algorithm View") # 调用函数绘制图像 glutDisplayFunc(self.drawFunc) glutIdleFunc(self.drawFunc) # glutReshapeFunc(self.reshapeFunc) # 鼠标事件 glutMouseFunc(self.camera.mouseFunc) # glutMouseWheelFunc(camera.mouseWheelFunc) glutMotionFunc(self.camera.mouse) glutKeyboardFunc(self.camera.keypress) glutSpecialFunc(self.camera.keypress) glClearColor(0.0, 0.0, 0.0, 0.0) glShadeModel(GL_SMOOTH) mat_specular = [1.0, 1.0, 1.0, 1.0] mat_shininess = [30.0] glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular) # 材质镜面反射 glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess) # 材质高光 white_light = [1.0, 1.0, 1.0, 1.0] Light_Model_Ambient = [0.2, 0.2, 0.2, 1.0] glLightfv(GL_LIGHT0, GL_POSITION, [1, 1, 1, 0]) glLightfv(GL_LIGHT0, GL_POSITION, [-1, -1, -1, 0]) glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light) # 漫反射 glLightfv(GL_LIGHT0, GL_SPECULAR, white_light) # 镜面反射 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, Light_Model_Ambient) # 环境光 glEnable(GL_COLOR_MATERIAL) glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) glEnable(GL_DEPTH_TEST) self.initData() # 主循环 # glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS) glutMainLoop() return w def initData(self): self.index = 0 self.timeSpan = 30 self.stacks = 30 self.pointCountRecord = self.getCommunity() self.epochs = len(self.pointCountRecord) self.n = len(self.pointCountRecord[0].keys()) self.outer_radius = .3 self.inner_radius = self.outer_radius * 2 * np.pi / self.n self.theta = np.linspace(0, 2 * np.pi, self.n + 1)[:-1] self.length = np.random.rand(self.n) self.colors = [[np.random.rand(), np.random.rand(), np.random.rand()] for i in range(self.n)] def getData(self): return self.stacks, self.pointCountRecord, self.epochs, self.n, self.outer_radius, self.inner_radius, \ self.theta, self.length, self.colors def getCommunity(self): lines = open(self.MUTUAL_INFORMATION_FILE, 'r').readlines() index = -1 mutualInformation = [] communityCluster = [] for line in lines: if not index < 10: communityCluster.remove([]) break if line.startswith("Q值为："): index += 1 i = line.strip()[4:] mutualInformation.append(i) communityCluster.append([]) elif '中的结点有：' in line: communityCluster[index].append(line.strip().split('：')[1]) else: pass pointCountRecord = [{}] for ci, c in enumerate(communityCluster[0]): for p in str(c).split(' '): pointCountRecord[0][p] = [ci, 1] for ei, e in enumerate(communityCluster[1:]): pointCount = deepcopy(pointCountRecord[ei]) # .copy() for ci, c in enumerate(e): for p in str(c).split(' '): if pointCount[p][0] == ci: pointCount[p][1] += 1 else: if pointCount[p][1] <= 1: pointCount[p] = [ci, 1] else: pointCount[p][1] -= 1 pointCountRecord.append(pointCount) return pointCountRecord if __name__ == "__main__": v = OpenGLView() v.getCommunity() v.openView() # # # """GLUT-based fonts""" # from OpenGL import GLUT # from OpenGL.GL import * # from OpenGLContext.scenegraph.text import fontprovider, font # from OpenGLContext.arrays import * # import logging # # log = logging.getLogger(__name__) # # # class GLUTBitmapFont(font.NoDepthBufferMixIn, font.BitmapFontMixIn, font.Font): # """A GLUT-provided Bitmap Font # # XXX current doesn't pay attention to fontStyle, should # get justification from it at least. # """ # # def __init__(self, fontStyle=None, specifier=None, charHeight=0): # """Initialise the bitmap font""" # self.fontStyle = fontStyle # if not specifier or not charHeight: # specifier, charHeight = GLUTFontProvider.match(fontStyle) # self.specifier = specifier # self._lineHeight = int(charHeight * 1.2) # self.charHeight = charHeight # self._displayLists = {} # # def createChar(self, char, mode=None): # """Create the single-character display list # """ # metrics = font.CharacterMetrics( # char, # GLUT.glutBitmapWidth(self.specifier, ord(char)), # self.charHeight # ) # list = glGenLists(1) # glNewList(list, GL_COMPILE) # try: # try: # if metrics.char != ' ': # GLUT.glutBitmapCharacter(self.specifier, ord(char)) # else: # glBitmap(0, 0, 0, 0, metrics.width, 0, None) # except Exception: # glDeleteLists(list, 1) # list = None # finally: # glEndList() # return list, metrics # # def lists(self, value, mode=None): # """Get a sequence of display-list integers for value # # Basically, this does a bit of trickery to do # as-required compilation of display-lists, so # that only those characters actually required # by the displayed text are compiled. # # NOTE: Must be called from within the rendering # thread and within the rendering pass! # """ # if __debug__: # log.info("""lists %s(%s)""", self, repr(value)) # lists = [] # for char in value: # list, metrics = self.getChar(char, mode=mode) # if list is not None: # lists.append(list) # if __debug__: # log.info("""lists %s(%s)->%s""", self, repr(value), lists) # return lists # # def lineHeight(self, mode=None): # """Retrieve normal line-height for this font # """ # return self._lineHeight # # # class _GLUTFontProvider(fontprovider.FontProvider): # """Singleton for creating new GLUTBitmapFonts # """ # format = "bitmap" # scale = 12 # bitmapFonts = { # 'TYPEWRITER': ( # (GLUT.GLUT_BITMAP_8_BY_13, 13), # (GLUT.GLUT_BITMAP_9_BY_15, 15), # ), # 'SERIF': ( # (GLUT.GLUT_BITMAP_TIMES_ROMAN_10, 10), # (GLUT.GLUT_BITMAP_TIMES_ROMAN_24, 24), # ), # 'SANS': ( # (GLUT.GLUT_BITMAP_HELVETICA_10, 10), # (GLUT.GLUT_BITMAP_HELVETICA_12, 12), # (GLUT.GLUT_BITMAP_HELVETICA_18, 18), # ), # } # bitmapFonts['ROMAN'] = bitmapFonts['SERIF'] # # def create(self, fontStyle, mode=None): # """Create a new font for the given fontStyle and mode""" # family, size = self.match(fontStyle, mode) # # get pre-existing font, register for this fontStyle # fontHash = self.fontHash(family, size) # if fontHash in self.fonts: # current = self.fonts.get(fontHash) # self.addFont(fontStyle, current) # return current # # no pre-existing, create # bitmapFont = GLUTBitmapFont(fontStyle, specifier=family, charHeight=size) # self.addFont(fontStyle, bitmapFont) # # extra registration for imprecise matching... # self.fonts[fontHash] = bitmapFont # return bitmapFont # # def key(self, fontStyle=None): # """Calculate our "font key" for the fontStyle # # If the font-key changes, we should be invalidating # our caches, but at the moment we aren't caching anything # 3-D providers will add the various 3-D-specific fields # from the FontStyle3D node. # """ # if not fontStyle: # return None # return ( # tuple(fontStyle.family), # fontStyle.size, # ) # # def match(self, fontStyle=None, mode=None): # """Attempt to find matching font for our fontstyle # # GLUT only provides a tiny number of fonts, so # this method is just scanning through the entire # set looking for something close. # """ # # 10 point roman, closest to VRML semantics... # family, size = self.bitmapFonts.get("SERIF")[0] # if fontStyle and fontStyle.family: # current = None # for specifier in fontStyle.family: # current = self.bitmapFonts.get(specifier.upper()) # if current: # # find closest size in the set of available sizes... # target = fontStyle.size * self.scale # diff, family, size = min([(abs(target - size), family, size) for (family, size) in current]) # if __debug__: # if diff: # log.info( # """Using size %s for GLUT bitmap font, not equal to target %s""", # size, # target, # ) # return (family, size) # # def enumerate(self, mode=None): # """Iterate through all available fonts (whether instantiated or not) # # Just returns the bitmapFonts keys, which will # get each of the font-types which are available. # """ # return self.bitmapFonts.keys() # # def fontHash(family, size): # """Given family and size get hashable key for lookups # # OpenGL-ctypes gives you the underlying GLUT font void*, whereas # PyOpenGL gave you an integer value # """ # try: # hash((family, size)) # except TypeError as err: # return (family.value, size) # else: # return (family, size) # # fontHash = staticmethod(fontHash) # # # GLUTFontProvider = _GLUTFontProvider() # GLUTFontProvider.registerProvider(GLUTFontProvider)