コード例 #1
0
  def save(self, data):
    diagram = None
    
    # try to retrieve an existing diagram
    if data['id'] != None and data['id'] != "":
      diagram = Diagram.get_by_key_name(data['id']) 
    
    # if we don't have on, create a new one
    if diagram == None:
      diagram = Diagram.create( id          = data['id'],
                                name        = data['name'],
                                source      = data['source'],
                                width       = data['width'],
                                height      = data['height'],
                                description = data['description'],
                                notes       = data['notes'],
                                owner       = data['author'] )
    else:  
      # update the relevant data
      diagram.name       = data['name'];
      diagram.source     = data['source'];
      diagram.width      = data['width'];
      diagram.height     = data['height'];
      diagram.descripton = data['description'];
      diagram.notes      = data['notes'];

    # persist the diagram, which will trigger the generation of a version
    diagram.persist();

    self.redirect( "/" + diagram.key().name() )
コード例 #2
0
    def get_all(
        s,
        *groups,
        plot=False
    ):  #could this be more efficient? maybe. returns members of all the intersections of n groups

        for i, x in enumerate(groups):
            if x.name is None:
                x.name = i  #need to fix this
        names = [
            frozenset(i) for i in Diagram.powerset([x.name for x in groups])
        ]

        t = []
        for i in s:
            temp = []
            for g in groups:
                if i in g:
                    temp.append(g.name)
            if temp:
                t.append(frozenset(temp))

        c = {i: 0 for i in names}
        for i in t:
            c[i] += 1
        if not plot:
            return c

        Diagram.create_diagram(len(groups),
                               names=[x.name for x in groups],
                               quantities=c)
コード例 #3
0
    def notify(self, event):
        """G.notify (...) -> None

        Notifies the Graph2D about an event.
        """
        if not self.sensitive:
            return

        if event.signal in SIGNALS_MOUSE:
            eventarea = self.rect_to_client()

            if (event.signal == SIG_MOUSEDOWN) and \
                   eventarea.collidepoint (event.data.pos):
                if event.data.button == 1:
                    self.focus = True

                # Mouse wheel.
                elif event.data.button == 4:
                    self.zoom_out()
                elif event.data.button == 5:
                    self.zoom_in()

                self.run_signal_handlers(SIG_MOUSEDOWN, event.data)
                event.handled = True

        elif (event.signal == SIG_DOUBLECLICKED):
            eventarea = self.rect_to_client()

            if eventarea.collidepoint(event.data.pos):
                # The y origin starts at the bottom left, thus we have
                # to invert the y value by using the height.
                self.origin = event.data.pos[0] - eventarea.x, \
                              self.height - event.data.pos[1] + eventarea.y
                self.run_signal_handlers(SIG_DOUBLECLICKED, event.data)
                event.handled = True

        elif self.focus and (event.signal == SIG_KEYDOWN):
            # Zoom in and out.
            if event.data.key in (K_PLUS, K_KP_PLUS):
                self.zoom_in()
                event.handled = True
            elif event.data.key in (K_MINUS, K_KP_MINUS):
                self.zoom_out()
                event.handled = True
            # Axis movement.
            elif event.data.key == K_UP:
                self.origin = (self.origin[0], self.origin[1] - 5)
                event.handled = True
            elif event.data.key == K_DOWN:
                self.origin = (self.origin[0], self.origin[1] + 5)
                event.handled = True
            elif event.data.key == K_LEFT:
                self.origin = (self.origin[0] + 5, self.origin[1])
                event.handled = True
            elif event.data.key == K_RIGHT:
                self.origin = (self.origin[0] - 5, self.origin[1])
                event.handled = True

        Diagram.notify(self, event)
コード例 #4
0
    def notify (self, event):
        """G.notify (...) -> None

        Notifies the Graph2D about an event.
        """
        if not self.sensitive:
            return

        if event.signal in SIGNALS_MOUSE:
            eventarea = self.rect_to_client ()

            if (event.signal == SIG_MOUSEDOWN) and \
                   eventarea.collidepoint (event.data.pos):
                if event.data.button == 1:
                    self.focus = True

                # Mouse wheel.
                elif event.data.button == 4:
                    self.zoom_out ()
                elif event.data.button == 5:
                    self.zoom_in ()

                self.run_signal_handlers (SIG_MOUSEDOWN, event.data)
                event.handled = True
                
        elif (event.signal == SIG_DOUBLECLICKED):
            eventarea = self.rect_to_client ()

            if eventarea.collidepoint (event.data.pos):
                # The y origin starts at the bottom left, thus we have
                # to invert the y value by using the height.
                self.origin = event.data.pos[0] - eventarea.x, \
                              self.height - event.data.pos[1] + eventarea.y
                self.run_signal_handlers (SIG_DOUBLECLICKED, event.data)
                event.handled = True
                 
        elif self.focus and (event.signal == SIG_KEYDOWN):
            # Zoom in and out.
            if event.data.key in (K_PLUS, K_KP_PLUS):
                self.zoom_in ()
                event.handled = True
            elif event.data.key in (K_MINUS, K_KP_MINUS):
                self.zoom_out ()
                event.handled = True
            # Axis movement.
            elif event.data.key == K_UP:
                self.origin = (self.origin[0], self.origin[1] - 5)
                event.handled = True
            elif event.data.key == K_DOWN:
                self.origin = (self.origin[0], self.origin[1] + 5)
                event.handled = True
            elif event.data.key == K_LEFT:
                self.origin = (self.origin[0] + 5, self.origin[1])
                event.handled = True
            elif event.data.key == K_RIGHT:
                self.origin = (self.origin[0] - 5, self.origin[1])
                event.handled = True

        Diagram.notify (self, event)
コード例 #5
0
  def get(self):
    updated = Diagram.all().order('-updated').fetch(10);
    viewed  = Diagram.all().order('-viewCount').fetch(10);

    template_values = {
      'updated' : updated,
      'viewed'  : viewed
    }
    render_template( self, 'ListDiagrams', template_values )
コード例 #6
0
    def set_data(self, data):
        """G.set_data (...) -> None

        Sets the data to evaluate.

        Raises a TypeError, if the passed argument is not a list or tuple.
        Raises a ValueError, if the passed argument values are not
        integers or floats.
        """
        if data != None:
            if type(data) not in (list, tuple):
                raise TypeError("data must be a list, tuple or array")
            ov = filter(lambda x: type(x) not in (int, float), data)
            if len(ov) != 0:
                raise ValueError("vales in data must be integers or float")
        Diagram.set_data(self, data)
コード例 #7
0
    def set_data (self, data):
        """G.set_data (...) -> None

        Sets the data to evaluate.

        Raises a TypeError, if the passed argument is not a list or tuple.
        Raises a ValueError, if the passed argument values are not
        integers or floats.
        """
        if data != None:
            if type (data) not in (list, tuple):
                raise TypeError ("data must be a list, tuple or array")
            ov = filter (lambda x: type (x) not in (int, float), data)
            if len (ov) != 0:
                raise ValueError ("vales in data must be integers or float")
        Diagram.set_data (self, data)
コード例 #8
0
    def get(self):
        key = self.request.path.replace("/", "")
        diagram = Diagram.get(key)

        if diagram:
            template_values = {"diagram": diagram}

            render_template(self, "ShowDiagram", template_values)
コード例 #9
0
def test():
        
    D = Diagram()
    A = Object(D,"A")
    AxA = Object(D,"AxA")
    f = Morphism(AxA,A,)
    g = Morphism(AxA,A)
    ProductProperty(f,g)
    
    RM = RuleMaster(D,prioritiser = UltimateWeightPriotiser)
    for _ in xrange(10):
        RM.rule(numberOfExtensions=3,verbose=True)
    D.printCommutativity()
    print D.Objects

#test()
#from cProfile import run
#run("test()")
コード例 #10
0
def get_and_count_diagram(key, request, response):
  diagram = Diagram.get(key);
  seen = '';
  if 'seen' in request.cookies: seen = request.cookies['seen'];
  if not "/" + key + "/" in seen:
    diagram.increase_view_count();
    seen += "/" + key + "/";
    response.headers.add_header( 'Set-Cookie','seen=' + seen + ';' );
  return diagram;
コード例 #11
0
    def __init__(self, width, height):
        Diagram.__init__(self)

        # Some defaults.
        self._zoom_factor = (1, 1)
        self._units = (20, 20)
        self._scaleunits = ("-", "-")
        self._axes = ("x", "y")

        self._shownames = True

        # Colors.
        self._axiscolor = (0, 0, 0)
        self._graphcolor = (255, 0, 0)

        # Signals.
        self._signals[SIG_KEYDOWN] = []
        self._signals[SIG_MOUSEDOWN] = []
        self._signals[SIG_DOUBLECLICKED] = []

        self.minsize = width, height
コード例 #12
0
def abeliantest():
    D = Diagram(category = AbelianCategory)
    
    A = Object(D,"A")
    B = Object(D,"B")
    f = Morphism(A,B,"f")
    
    #K = Object(D,"K")
    #iker = Morphism(K,A,"ker_f")
    #Kernel(f,iker)
    
    C = Object(D,"C")
    g = Morphism(C,A,"g")
    
    SetEqualZero(f*g)

    Rules = abelianRules+[ComposeRule,ExistIdentity]
    RM = RuleMaster(D,Rules = Rules, prioritiser = UltimateWeightPriotiser)
    for _ in xrange(40):
        RM.rule(verbose=True)
    D.printCommutativity()
コード例 #13
0
    def __init__ (self, width, height):
        Diagram.__init__ (self)

        # Some defaults.
        self._zoom_factor = (1, 1)
        self._units = (20, 20)
        self._scaleunits = ("-", "-")
        self._axes = ("x", "y")

        self._shownames = True

        # Colors.
        self._axiscolor = (0, 0, 0)
        self._graphcolor = (255, 0, 0)

        # Signals.
        self._signals[SIG_KEYDOWN] = []
        self._signals[SIG_MOUSEDOWN] = []
        self._signals[SIG_DOUBLECLICKED] = []
        
        self.minsize = width, height
コード例 #14
0
    def draw(self):
        """W.draw () -> None

        Draws the Graph2D surface.

        Creates the visible surface of the Graph2D.
        """
        Diagram.draw(self)
        surface = self.image
        rect = surface.get_rect()

        # Orientation swapped?
        swap = self.orientation == ORIENTATION_VERTICAL

        # Coordinates.
        origin = (rect.left + self.origin[0], rect.bottom - self.origin[1] - 1)

        unitx = 1.0
        unity = 1.0
        if self.units and (len(self.units) > 1):
            if self.orientation == ORIENTATION_VERTICAL:
                unitx = self.units[1]
                unity = self.units[0]
            else:
                unitx = self.units[0]
                unity = self.units[1]

        self._draw_axes(surface, rect, origin, unitx, unity)

        data = self.data
        values = self.values

        if data and values:
            # Filter negative values.
            if not self.negative:
                data = filter(lambda x: x >= 0, data)
                values = filter(lambda y: y >= 0, values)

            # Create the coordinate tuples and take the unit resolution into
            # account.
            coords = []
            org0 = origin[0]
            org1 = origin[1]
            if self.orientation == ORIENTATION_VERTICAL:
                coords = map(
                    lambda x, y: (int(org1 +
                                      (x * unitx)), int(org0 + (y * unity))),
                    data, values)
            else:
                coords = map(
                    lambda x, y: (int(org0 +
                                      (x * unitx)), int(org1 - (y * unity))),
                    data, values)

            # Filter non-visible values.
            width = self.width
            height = self.height
            coords = filter (lambda (x, y): (0 < x < width) and \
                             (0 < y < width), coords)

            # Draw them.
            color = self.graph_color
            setat = surface.set_at
            for xy in coords:
                setat(xy, color)
コード例 #15
0
    def draw (self):
        """W.draw () -> None

        Draws the Graph2D surface.

        Creates the visible surface of the Graph2D.
        """
        Diagram.draw (self)
        surface = self.image
        rect = surface.get_rect ()

        # Orientation swapped?
        swap = self.orientation == ORIENTATION_VERTICAL
        
        # Coordinates.
        origin = (rect.left + self.origin[0],
                  rect.bottom - self.origin[1] - 1)

        unitx = 1.0
        unity = 1.0
        if self.units and (len (self.units) > 1):
            if self.orientation == ORIENTATION_VERTICAL:
                unitx = self.units[1]
                unity = self.units[0]
            else:
                unitx = self.units[0]
                unity = self.units[1]

        self._draw_axes (surface, rect, origin, unitx, unity)
        
        data = self.data
        values = self.values

        if data and values:
            # Filter negative values.
            if not self.negative:
                data = filter (lambda x: x >= 0, data)
                values = filter (lambda y: y >= 0, values)
            
            # Create the coordinate tuples and take the unit resolution into
            # account.
            coords = []
            org0 = origin[0]
            org1 = origin[1]
            if self.orientation == ORIENTATION_VERTICAL:
                coords = map (lambda x, y: (int (org1 + (x * unitx)),
                                            int (org0 + (y * unity))),
                              data, values)
            else:
                coords = map (lambda x, y: (int (org0 + (x * unitx)),
                                            int (org1 - (y * unity))),
                              data, values)

            # Filter non-visible values.
            width = self.width
            height = self.height
            coords = filter (lambda (x, y): (0 < x < width) and \
                             (0 < y < width), coords)
            
            # Draw them.
            color = self.graph_color
            setat = surface.set_at
            for xy in coords:
                setat (xy, color)