Changeset 12717

Timestamp:

25.10.2009 15:49:35 (4 weeks ago)

Author:

raider

Message:

hidden edges are now filtered befor calculating compressed paths. see #753

Files:

• trunk/GUI/GraphLogic.hs (modified) (4 diffs)

trunk/GUI/GraphLogic.hs

@@ -131 +131 @@
                       , options = opts }) -> do
       flags <- readIORef opts
-      let (nodes, comp) = if flagHideNodes flags then hideNodesAux dg
+      let edges = if flagHideEdges flags then hideEdgesAux dg else []
+          (nodes, comp) = if flagHideNodes flags then hideNodesAux dg edges
                           else ([],[])
-          edges = if flagHideEdges flags then hideEdgesAux dg else []
       GA.showTemporaryMessage gi
         "Applying development graph calculus proof rule..."
@@ -167 +167 @@
 
 -- | hides all unnamed internal nodes that are proven
-hideNodesAux :: DGraph
+hideNodesAux :: DGraph -> [EdgeId]
              -> ([GA.NodeId], [(GA.NodeId, GA.NodeId, DGEdgeType, Bool)])
-hideNodesAux dg =
+hideNodesAux dg ignoreEdges =
   let nodes = selectNodesByType dg [DGNodeType { nonRefType = NonRefType
                                                  { isProvenCons = True
                                                  , isInternalSpec = True}
                                                , isLocallyEmpty = True}]
-      edges = getCompressedEdges dg nodes
+      edges = getCompressedEdges dg nodes ignoreEdges
   in (nodes, edges)
 
@@ -240 +240 @@
   | otherwise = compressTypes False (t2:r)
 
+-- | innDG with filter of not shown edges
+fInnDG :: [EdgeId] -> DGraph -> Node -> [LEdge DGLinkLab]
+fInnDG ignore dg = filter (\ (_,_,l) -> elem (dgl_id l) ignore) . innDG dg
+
+-- | outDG with filter of not shown edges
+fOutDG :: [EdgeId] -> DGraph -> Node -> [LEdge DGLinkLab]
+fOutDG ignore dg = filter (\ (_,_,l) -> elem (dgl_id l) ignore) . outDG dg
+
 -- | returns a list of compressed edges
-getCompressedEdges :: DGraph -> [Node] -> [(Node,Node,DGEdgeType, Bool)]
-getCompressedEdges dg hidden = filterDuplicates $ getShortPaths
-  $ concatMap (\ e@(_,t,_) -> map (e:) $ getPaths dg t hidden []) inEdges
+getCompressedEdges :: DGraph -> [Node] -> [EdgeId]
+                   -> [(Node,Node,DGEdgeType, Bool)]
+getCompressedEdges dg hidden ign = filterDuplicates $ getShortPaths
+  $ concatMap (\ e@(_,t,_) -> map (e:) $ getPaths dg t hidden [] ign) inEdges
   where
     inEdges = filter (\ (_,t,_) -> elem t hidden)
-                     $ concatMap (outDG dg)
+                     $ concatMap (fOutDG ign dg)
                      $ foldr (\ n i -> if elem n hidden
                                        || elem n i then i else n:i) []
-                     $ map (\ (s,_,_) -> s) $ concatMap (innDG dg) hidden
+                     $ map (\ (s,_,_) -> s) $ concatMap (fInnDG ign dg) hidden
 
 -- | filter duplicate paths
@@ -264 +273 @@
 
 -- | returns the pahts of a given node through hidden nodes
-getPaths :: DGraph -> Node -> [Node] -> [Node] -> [[LEdge DGLinkLab]]
-getPaths dg node hidden seen' = if elem node hidden then
+getPaths :: DGraph -> Node -> [Node] -> [Node] -> [EdgeId]
+         -> [[LEdge DGLinkLab]]
+getPaths dg node hidden seen' ign = if elem node hidden then
   if null edges then []
-    else concatMap (\ e@(_,t,_) -> map (e:) $ getPaths dg t hidden seen) edges
+    else concatMap (\ e@(_,t,_) -> map (e:) $ getPaths dg t hidden seen ign)
+                   edges
   else [[]]
   where
     seen = node:seen'
-    edges = filter (\ (_,t,_) -> notElem t seen) $ outDG dg node
+    edges = filter (\ (_,t,_) -> notElem t seen) $ fOutDG ign dg node
 
 -- | returns source and target node of a path with the compressed type