algorithmView.py

# # -*- 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)