[ff-cvs] fenfire/org/fenfire demo/mm.py fenmm/MMNode.jav...

[Asko Soukka]

CVSROOT:        /cvsroot/fenfire
Module name:    fenfire
Branch:         
Changes by:     Asko Soukka <address@hidden>    03/08/25 03:27:51

Modified files:
        org/fenfire/demo: mm.py 
        org/fenfire/fenmm: MMNode.java MindNet.java 
        org/fenfire/view/lava: mindMapView2D.py 
Added files:
        org/fenfire/fenmm: MMGeometry.java MMPlace.java 

Log message:
        abstracting geometery, though, it's now temporarily broken, rotating 
makes feel dizzy =)

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/fenfire/fenfire/org/fenfire/demo/mm.py.diff?tr1=1.34&tr2=1.35&r1=text&r2=text
http://savannah.gnu.org/cgi-bin/viewcvs/fenfire/fenfire/org/fenfire/fenmm/MMGeometry.java?rev=1.1
http://savannah.gnu.org/cgi-bin/viewcvs/fenfire/fenfire/org/fenfire/fenmm/MMPlace.java?rev=1.1
http://savannah.gnu.org/cgi-bin/viewcvs/fenfire/fenfire/org/fenfire/fenmm/MMNode.java.diff?tr1=1.1&tr2=1.2&r1=text&r2=text
http://savannah.gnu.org/cgi-bin/viewcvs/fenfire/fenfire/org/fenfire/fenmm/MindNet.java.diff?tr1=1.4&tr2=1.5&r1=text&r2=text
http://savannah.gnu.org/cgi-bin/viewcvs/fenfire/fenfire/org/fenfire/view/lava/mindMapView2D.py.diff?tr1=1.37&tr2=1.38&r1=text&r2=text

Patches:
Index: fenfire/org/fenfire/demo/mm.py
diff -u fenfire/org/fenfire/demo/mm.py:1.34 fenfire/org/fenfire/demo/mm.py:1.35
--- fenfire/org/fenfire/demo/mm.py:1.34 Sun Aug 24 06:52:11 2003
+++ fenfire/org/fenfire/demo/mm.py      Mon Aug 25 03:27:51 2003
@@ -29,6 +29,7 @@
 from org.fenfire.vocab import *
 from org.fenfire.vocab.lava import *
 from org.fenfire.swamp import Nodes
+from org.fenfire.fenmm import MMGeometry
 from org.nongnu.libvob.util import PUIClipboard
 import org.nongnu.alph as alph
 import org.nongnu.storm as storm
@@ -208,10 +209,6 @@
     def setSlowAnimation(self):
         self.fastMouseChg = 0
         self.replaceVS = None
-    def getScale(self, depth):
-        return 1-(Math.log(depth+1)/Math.E)
-    def getTextScale(self, depth):
-        return 1-(Math.log(depth+1)/Math.E)/2
 
 class Action:
     def __init__(self, fen, context):
@@ -250,7 +247,7 @@
             scale = 1./main.getFocus().getZoom()
 
             # scaling
-            nodeScale = self.context.getTextScale(100+into[2])
+            nodeScale = ff.fenmm.MMGeometry.getTextScale(int(100+into[2]))
 
             if node == self.context.main.getPlane(): # from border to linked
                 cursor.setOffset((x-into[0])/scale/nodeScale, 
(y-into[1])/scale/nodeScale)
@@ -325,9 +322,13 @@
         self.mindMouse.setListener(1, 0,'Moving the pan around or the node if 
accursed.', \
                           PanMover(fen, self.context))
 
-        self.view = ff.view.lava.mindMapView2D.MindMapView2D(fen, 
self.context, 5)
+        self.view = ff.view.lava.mindMapView2D.MindMapView2D(fen, self.context)
         self.main = ff.view.lava.mindMapView2D.MindMapMainNode2D(fen, 
self.context, self.view, self.mindMouse)
         self.context.main = self.main
+        dimensions = w.getSize()
+        self.view.filletLength = dimensions.width * 1./4.
+        self.view.filletWidth = dimensions.height * 1./15.
+        self.view.depth = 5
 
         # flag for cursor('wait')
         self.startup = 1 
@@ -346,10 +347,10 @@
             self.axes = [None, None, None]
 
             if self.naxes >= 1:
-                self.axes[0] = vob.input.impl.StandardBoundedFloatModel(0.001, 
self.view.filletWidth*2,
+                self.axes[0] = vob.input.impl.StandardBoundedFloatModel(1, 
self.view.filletWidth*2,
                     actionPerformed = lambda x: 
vob.AbstractUpdateManager.chg())
             if self.naxes >= 2:
-                self.axes[1] = vob.input.impl.StandardBoundedFloatModel(0.001, 
self.view.filletLength*2,
+                self.axes[1] = vob.input.impl.StandardBoundedFloatModel(1, 
self.view.filletLength*2,
                     actionPerformed = lambda x: 
vob.AbstractUpdateManager.chg())
             if self.naxes >= 3:
                 self.axes[2] = vob.input.impl.WrappingBoundedFloatModel(0, 
Math.PI*2, 
@@ -370,7 +371,7 @@
         # custom controller support
         if self.naxes >= 1: self.view.filletWidth = self.axes[0].getValue()
         if self.naxes >= 2: self.view.filletLength = self.axes[1].getValue()
-        if self.naxes >= 3: self.view.rotation = -self.axes[2].getValue()
+        if self.naxes >= 3: self.view.initRotation = -self.axes[2].getValue()
 
         accursed = self.context.c.getAccursed()
         # adding accursed to multiplexer
Index: fenfire/org/fenfire/fenmm/MMNode.java
diff -u fenfire/org/fenfire/fenmm/MMNode.java:1.1 
fenfire/org/fenfire/fenmm/MMNode.java:1.2
--- fenfire/org/fenfire/fenmm/MMNode.java:1.1   Sun Aug 17 20:50:20 2003
+++ fenfire/org/fenfire/fenmm/MMNode.java       Mon Aug 25 03:27:51 2003
@@ -24,7 +24,7 @@
  * Written by Matti J. Katila, Asko Soukka
  */
 
-/** MMNode structure stores the Node and its related MM spesific information.
+/** MMNode structure stores a Node and its related MM spesific information.
  * The drawing depth is quite important factor in FenMM structure view.
  * Since nodes are not necessarily drawn in depth order, it should be
  * stored with node.
Index: fenfire/org/fenfire/fenmm/MindNet.java
diff -u fenfire/org/fenfire/fenmm/MindNet.java:1.4 
fenfire/org/fenfire/fenmm/MindNet.java:1.5
--- fenfire/org/fenfire/fenmm/MindNet.java:1.4  Sun Aug 17 21:07:15 2003
+++ fenfire/org/fenfire/fenmm/MindNet.java      Mon Aug 25 03:27:51 2003
@@ -83,7 +83,7 @@
         ((ArrayList)net.get(a)).add(b);
     }
 
-    public Object put(Object a, Object pl, int depth) {
+    public Object put(Object a, MMPlace pl, int depth) {
        return data.put(a, new MMNode(pl, depth));
     }
     
@@ -92,12 +92,12 @@
        return (MMNode)data.get(a);
     }
 
-    public Object getPlace(Object a) {
+    public MMPlace getPlace(Object a) {
         if (data.get(a) == null) return null;
-       return ((MMNode)data.get(a)).object;
+       return (MMPlace)((MMNode)data.get(a)).object;
     }
 
-    public int  getDepth(Object a) {
+    public int getDepth(Object a) {
         if (data.get(a) == null) return -1;
        return ((MMNode)data.get(a)).depth;
     }
Index: fenfire/org/fenfire/view/lava/mindMapView2D.py
diff -u fenfire/org/fenfire/view/lava/mindMapView2D.py:1.37 
fenfire/org/fenfire/view/lava/mindMapView2D.py:1.38
--- fenfire/org/fenfire/view/lava/mindMapView2D.py:1.37 Sun Aug 24 06:52:11 2003
+++ fenfire/org/fenfire/view/lava/mindMapView2D.py      Mon Aug 25 03:27:51 2003
@@ -26,8 +26,8 @@
 import org.fenfire as ff
 from org.fenfire.vocab import STRUCTLINK, RDF
 from org.fenfire.vocab.lava import MINDSTRUCT
-
-from org.fenfire.fenmm import MindNet
+from org.fenfire.util.lava import Traversals
+from org.fenfire.fenmm import MindNet, MMGeometry
 
 def p(*s):
     print 'mindMapView2D', s
@@ -115,23 +115,16 @@
         vs.coords.activate(cs)
 
 class MindMapView2D(ff.view.View2D):
-    def __init__(self, fen, context, depth):
+    def __init__(self, fen, context):
         self.fen = fen
         self.context = context
 
         self.multiplexer = self.context.multiplexer
 
-        self.filletWidth = 15. # divider
-        self.filletLength = 4. # divider
-        self.rotation = 0.
-
-        self.maxDepth = depth
-
-        self.box = None
-
-        # Stored data to help interpolation to nodes next to accursed
-        self.current = {'centerNode': None, 'startAngle': 0., 'rotationAngle': 
0.}
-        self.previous = {'centerNode': None, 'startAngle': 0., 
'rotationAngle': 0.}
+        self.depth = 5
+        self.filletWidth = 20
+        self.filletLength = 150
+        self.initRotation = 0
         
         # fillet set up
         self.angle = 1
@@ -155,90 +148,33 @@
         self.tblsize = 20
         self.mode = 0
 
-    def getNodeSize(self, depth):
-        """Node size is relative to depth as 1-(Math.log(depth)/Math.E)."""
-        assert depth <= self.maxDepth, 'Depth is greater than maxDepth.'
-
-        s =(self.box[1] * 1./self.filletWidth) * self.context.getScale(depth)
-        if dbg: p('fillet size:', s)
-        return s
-
-    def getDistance(self, depth):
-        """Node distance is relative to depth as 1-(Math.log(depth)/Math.E)."""
-        assert depth <= self.maxDepth, 'Depth is greater than maxDepth.'
-        if depth == 0: return 0
-
-        d = (self.box[0] * 1./self.filletLength) * self.context.getScale(depth)
-        if dbg: p('fillet length: ', d)
-        return d
+        self.oldCenter = None
 
     def render(self, vs, node,
                matchingParent, box2screen, box2plane):
         self.matchingParent = matchingParent
-#        p("Rendering view.")
-
-#      if dbg:
-#            p('Drawing screenbox')
-#          dbg1 = vs.unitSqCS(box2screen, "UNIT_SCREEN")
-#          vs.put(vob.coloredQuad((0,1,0)), dbg1)
-
-#      paper2box = vs.invertCS(box2plane, "minMap_INv")
-#      paper2screen = vs.concatCS(box2screen, 'mindMap_CONCAT',
-#                                   paper2box)
 
        paper2screen = vs.concatCS(box2screen, 'mindMap_CONCAT',
                                    box2plane)
         box = jarray.zeros(2, 'f')
         vs.coords.getSqSize(box2screen, box)
-        self.box = box
-
        paper2screen = vs.translateCS(paper2screen, 'mindMap_TRANS',
                                    box[0], box[1], 0)
         # XXX
         self.zoomPanCS = paper2screen
         
-        # links between nodes and also storin nodes currently.
-        self.net = MindNet()
-
-
-        ### Get the cs for center node
-        pl = self.getPlace(vs, paper2screen, 0,0, node, 0,0)
-        self.net.put(node, pl, 0)
-
-        # If update interpolation help data only, if has moved
-        if self.current['centerNode'] != node: self.previous = 
self.current.copy()
-                         
-        links = self.getLinks(self.fen, node)
-
-        # Now, let's see, where we have came from...
-        previousIndex = None
-        currentIndex = None
-        if (self.previous['centerNode'] != None):
-            previousLinks = self.getLinks(self.fen, 
self.previous['centerNode'])
-            try:
-                previousIndex = previousLinks.index(node)
-                currentIndex = links.index(self.previous['centerNode'])
-            except ValueError: pass
-
-        if len(links) == 0:
-            self.net.link(node, node) # XXX probably not the right way
-        if len(links) > 0:
-            rotationAngle = 2*Math.PI / float(len(links))
-
-            # Calculates the "correct" starting angle
-            if previousIndex != None and currentIndex != None:
-                startAngle = self.previous['startAngle'] \
-                             + 
self.previous['rotationAngle']*float(previousIndex)-Math.PI \
-                             + rotationAngle*float(len(links)-currentIndex)
-            else: startAngle = 0
-
-            for i in range(2, self.maxDepth+1):
-                self.doMindMapCS(vs, paper2screen, node, None, links, 0,0,
-                                 startAngle + self.rotation, rotationAngle, 1, 
i)
-            self.current['startAngle'] = startAngle
-            self.current['rotationAngle'] = rotationAngle
+        path = Traversals.findShortestPath((self.oldCenter or node),
+                                          STRUCTLINK.linkedTo,
+                                          node, self.fen.graph)
+        if not path or path.size() == 0:
+            path = java.util.ArrayList(1)
+            path.add(node)
+         
+        geometry = MMGeometry(self.fen.graph, self.filletLength, 
self.filletWidth,
+                              self.initRotation, self.depth)
+        self.net = geometry.buildMindNet(vs, paper2screen, path)
         self.drawMindMap(vs)
-        self.current['centerNode'] = node
+        self.oldCenter = node
 
     def drawMindMap(self, vs):
         i = self.net.iterator()
@@ -246,15 +182,15 @@
             node = i.next()
             pl = self.net.getPlace(node)
             if pl == None: continue
-            c = [ pl[0] ]
+            c = [ pl.cs ]
 
             it = self.net.iterator(node)
             while it.hasNext():
                 n = it.next()
                 pl2 = self.net.getPlace(n)
                 if pl2 == None: continue
-                c.append(pl2[0])
-                if dbg: p('info:', pl2[0], pl2[1], pl2[2])
+                c.append(pl2.cs)
+                if dbg: p('info:', pl2.cs, pl2.x, pl2.y)
 
             if dbg: p('Fillet coordinates:', c)
             def pc(conns, cs):
@@ -266,93 +202,21 @@
             vob.fillet.light3d.drawFillets(self, vs, pc)
 
             # draw text etc..
-            cs = vs.coords.translate(pl[0], 0,0, -100)
+            cs = vs.coords.translate(pl.cs, 0,0, -100)
             vs.matcher.add(self.matchingParent, cs, node)
             self.putNodeContent(vs, node, cs)
 
-    def getLinks(self, fen, node):
-        """Get all links available with node."""
-        nodes = []
-        iter = fen.graph.findN_11X_Iter(node, STRUCTLINK.linkedTo)
-        while iter.hasNext():
-            nodes.append(iter.next())
-        iter = fen.graph.findN_X11_Iter(STRUCTLINK.linkedTo, node)
-        while iter.hasNext():
-            nodes.append(iter.next())
-        if dbg: p('Found linked nodes: ', nodes)
-        return nodes
-
-    def doMindMapCS(self, vs, into, centerNode, oldCenter, links, x, y,
-                    startAngle, rotationAngle, depth, maxDepth):
-        """ Recursively go through all cs """
-        fen = self.fen
-
-        if depth < maxDepth:
-            for i in range(len(links)):
-                link = links[i]
-                if link == centerNode: raise 'own node!!'
-                if self.net.hasBeenLinked(centerNode, link): continue
-                self.net.link(centerNode, link)
-            
-                if self.net.getPlace(link) == None:
-                    pl = self.getPlace(vs, into, x, y, link, 
startAngle+rotationAngle*i, depth)
-                    if dbg: p('Add a new node', pl)
-                    self.net.put(link, pl, depth)
-                else:
-                    pl = self.net.getPlace(link)
-                    if dbg: p('Reached an old node', pl)
-
-        if depth >= maxDepth: return
-        for i in range(len(links)):
-            link = links[i]
-            if link == oldCenter: continue
-
-            place = self.net.getPlace(link)
-            newLinks = self.getLinks(fen, link)
-            newAngle = Math.PI*2./float(len(newLinks))
-
-            fromIndex = None
-            try: fromIndex = newLinks.index(centerNode)
-            except ValueError: pass
-            if fromIndex != None:
-                newStartAngle = (startAngle+rotationAngle*i-Math.PI) \
-                                + newAngle*float(len(newLinks)-fromIndex)
-            else: newStartAngle = 0
-            
-            self.doMindMapCS(vs, into, link, centerNode, newLinks, place[1], 
place[2],
-                             newStartAngle, newAngle, depth + 1, maxDepth)
-            
-    def getPlace(self, vs, into, x0,y0, key, angle, depth):
-        xy = self.getXY(x0,y0, angle, depth)
-        x,y = xy[0], xy[1]
-
-        s = self.getNodeSize(depth)
-        if (dbg): print 'size', s
-        cs = vs.orthoBoxCS(into,'foo'+str(key),depth, x-s/2.0,y-s/2.0, 1,1, 
s,s)
-        if dbg:
-            p('Place seed:',x0, y0, angle)
-            p('Constructed place:',cs, xy, angle, s)
-        return [cs, x, y, angle]
-
-    def getXY(self, x0, y0, angle, depth):
-        if depth == 0: return [0,0]
-
-        r = self.getDistance(depth)
-        x = x0 + Math.sin(angle) * r
-        y = y0 + Math.cos(angle) * r
-        return [x,y, r]
-
-
     def putNodeContent(self, vs, node, cs):
         # scaling after depth
         depth = self.net.getDepth(node)
-        scale = self.context.getTextScale(depth)
+        scale = ff.fenmm.MMGeometry.getScale(depth)
+        textScale = ff.fenmm.MMGeometry.getTextScale(depth)
 
         p = self.multiplexer.f(self.fen.graph, node) 
 
-        x = self.getNodeSize(depth)/2 - (p.getWidth()*scale)/2.0
-        y = self.getNodeSize(depth)/2 - (p.getHeight()*scale)/2.0
+        x = (self.filletWidth*scale)/2 - (p.getWidth()*textScale)/2.0
+        y = (self.filletWidth*scale)/2 - (p.getHeight()*textScale)/2.0
 
-        cs = vs.orthoBoxCS(cs,node,0, x,y, scale, scale, p.getWidth(), 
p.getHeight())
+        cs = vs.orthoBoxCS(cs,node,0, x,y, textScale, textScale, p.getWidth(), 
p.getHeight())
         p.place(vs, cs)
         vs.coords.activate(cs)