集合之间的关系：
    1.两个集合是否相等：
        可以使用运算符 == 或者 ！= 进行判断
    2.一个集合是否是另一个集合的子集：
        可以使用issubset（）来判断
    3.一个集合是否是另一个集合的超集：
        可以调用方法issuperset（）进行判断
    4.两个集合是否有交集：
        可以调用方法isdisjoint进行判断

代码
"""
    集合之间的关系：
        1.两个集合是否相等：
            可以使用运算符 == 或者 ！= 进行判断
        2.一个集合是否是另一个集合的子集：
            可以使用issubset（）来判断
        3.一个集合是否是另一个集合的超集：
            可以调用方法issuperset（）进行判断
        4.两个集合是否有交集：
            可以调用方法isdisjoint进行判断
"""
set2 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
set3 = {9, 8, 7, 6, 4, 5, 1, 2, 3}
set4 = {1, 2, 3, 4, 5, 6}
print(set2 == set3)
print(set2 != set3)
print(set2.issubset(set3))  # set2是set3的子集
print(set4.issubset(set2))  # set4是set2的子集
print(set2.issuperset(set4))  # set2是set4的超集



截图

背景

最近遇到一个有趣的问题，如何在CityEgnine中判断有接触或相交关系的模型，从而自动进行建模？

这个问题有点抽象，我们来看个实例，了解下问题的背景:

以往绝大多数情况下，我们拿到的2D建筑物底面（FootPrint）都是一个建筑对应一个面，也就是这样的：



实际生活中的的建筑物可能是更复杂的，例如商场、大型会议中心、复杂居民楼等参差不齐的多栋联合建筑，我们可以采集多个底面来表示建筑物，例如这样：



使用多个底面表示一栋复杂建筑物的做法可以很大程度上简化建模的工作，因此无可厚非。 但是问题来了，因为是彼此独立的Footprint，建模时若不加判断，就会出现如下图所示的情况，好像“空中地下室”。这样的房子既不美观也不实际。








解决方法

CityEngine的真正魅力在于“动态”建模，这是CE的创作者一直想要传播的理念。 CityEgnine提供很多内置函数解决这些问题，其中有一组为：Occlusion Functions，包含：inside，overlaps，touches 三个函数。 我们可以利用 touches() 来实现判断。

先写段简单的来了解下函数用法：



Init --> 
     extrude(40) Mass
Mass -->
     comp(f){top:NIL| side:Side} 
Side --> 
     case touches(): color(1,0,0) ShareSide
     else: Walls



针对前面“空中地下室”的问题，可以在楼层切割到窗户和墙体的时候做个判断，楼层不touch其他楼层时，再进行分割。

可以实现这个样子：



全部 CGA 代码共享给大家：



/**
 * File:    TestTouches.cga
 * Created: 1 Apr 2016 13:00:24 GMT
 * Author:  kikita
 */

version "2015.2"

# Define Attributes
attr AVG_HEIGHT = 0
attr WindowsWidth = 8
attr WallWidth = 2.5

# Building Schmetic
Init --> 
     extrude(AVG_HEIGHT) Mass
Mass -->
     comp(f){top:Top|side:Walls}
Walls -->
     split(y) { 15 : GroundFloor | {~10 : UpperFloors } * }

# Ground Floor
GroundFloor --> 
   setupProjection(0, scope.xy, '1, '1)
   projectUV(0) 
   texture("GroundFloor.jpg") 

# All Upper Floors
UpperFloors --> 

# Use touches() function
    case touches():
         setupProjection(0, scope.xy, 10, 10)
         projectUV(0) 
         texture("Wall/wall_grey.jpg")
    else:
         split(x){ ~WallWidth : AllWalls |
                 { ~WindowsWidth : WindowTiles |
                   ~WallWidth : AllWalls } * }                 
         WindowTiles -->
            split(y){ ~WallWidth/2: AllWalls |
                      ~WindowsWidth : Windows|
                      ~WallWidth/2 :AllWalls }

# Wall Texture      
AllWalls -->    
      setupProjection(0, scope.xy, 10, 10)
      projectUV(0) 
      texture("Wall/wall_grey.jpg")

# Windows  
Windows --> 
      color("DAFAF3")
      i("Windows/sash_window.obj") 
      s('1,'1,'2)          

# Roofs
Top --> 
      offset(-0.5)
      comp(f){ border : RoofEdge | inside : RoofFlat }     
RoofFlat -->
      setupProjection(0, scope.xy, '1, '1)
      projectUV(0) 
      texture("flatroof6.bw.jpg")     
RoofEdge --> 
      extrude(1) 


明天就放假了

节日愉快

我说的是愚人节

哈

Also available Here .

本算法通过遍历整个有向图来获取已选节点的关系，通过本算法，可以轻松的获得已选节点在其有向图中的流向关系，如下图，通过本算法我们可以和容易的发现A与C的流向关系是A -> C 而不是 A <- C
\

本算法的实现步骤是：
1.遍历整个有向图
2.每次遍历，查看当前节点是否为已选节点之一，
3.若是，建立集合存储已选节点(这里暂且称为临时集合)，实现中用的是集合是HashMap
4.若果临时集合元素个数不为0，则将刚加入临时集合的节点名称放入临时集合已有元素的containNode字段中，containNode字段的值是一个类型为String的HashSet
5.若临时集合已有的某个节点的所以子孙节点已遍历完毕，则将该节点所对应的元素从临时集合中删除。
由于本算法需要遍历整个有向图，因此时间复杂度是遍历整个有向图的复杂度；另，关于有向图的遍历方法，在文章《有向图闭环检测值java代码实现》中有论述，这里就不再说明了，当然本算法实现也是有文章《有向图闭环检测值java代码实现》的实现修改得来，对于遍历的修改点如下：
1.修改了traverseInDigraph()方法，取消了对"isFrozen"属性值得检测，因为本算法需要深度的遍历整个有向图。
2.修改了getNextNodeIndexInDigraph()方法，增加了对"isFrozen"的属性值检测，确保可以深度遍历整个有向图。
3.修改了traverseInDigraph()，在前进时将下一节点放入临时集合，后退时将临时集合里对应的元素放入返回之中，同时删除临时集合中对应的元素
具体实现代码如下：
/**
	 * 
	 * 功能：在有向图中寻找 已选节点的关系
	 * 作者：EugeneJao
	 * @param nodeCollections
	 * @param nodes
	 * @return
	 * @throws Exception
	 */
	public Map<String,Map<String,Object>> seekRelation(Map<String,Map<String,Object>> nodeCollections , List<String> nodes) throws Exception{
		
		Map<String,Map<String,Object>> ret = new HashMap<String, Map<String,Object>>();
		/**
		 * 如果前进至某已选节点则将该已选节点放入inn，
		 * 若已从相应已选节点中后退，则从inn移出该节点
		 * ，感觉就像是供游客暂歇的旅馆
		 */
		Map <String,Map<String,Object>> inn = new HashMap<String, Map<String,Object>>();
		/**
		 * 初始化"起点
		 */
		String startNode = getOriginInDigraph(nodeCollections);
		/**
		 * 初始化"视野"
		 */
		Map<String,String> nodeName = new HashMap<String, String>() ;
		nodeName.put("nextNode", startNode);
		nodeName.put("curNode", startNode);
		nodeName.put("beforeNode", startNode);

		while(!(nodeName.get("beforeNode").equals(nodeName.get("curNode")) 
				&& nodeName.get("nextNode") == null )){
			/**
			 * 遍历每个节点
			 */
			nodeName = traverseInDigraphForSeek(nodeCollections, nodeName, inn, nodes,ret);
			
			
		}
		
		return ret;
	}
		
	/**
	 * 
	 * 功能：在有向图中访问某个网络节点
	 * 作者：EugeneJao
	 * @param nodeCollections
	 * @param nodeName
	 * @param inn
	 * @param ret 
	 * @return
	 * @throws Exception
	 */
	private Map<String,String> traverseInDigraphForSeek(Map<String,Map<String,Object>> nodeCollections , Map<String,String> nodeName ,
			Map<String, Map<String, Object>> inn , List<String> nodes, Map<String, Map<String, Object>> ret) throws Exception{
		/**
		 * 判断前进节点在网络中存不存在
		 */
		if(nodeName.get("nextNode") != null){
			if(!(nodeCollections.containsKey(nodeName.get("nextNode")))){
				throw new Exception("节点网络构建异常,网络中不存在节点:" + nodeName);
			}
		}
		
		if(nodeName.get("curNode") == null || nodeName.get("beforeNode") == null){
			throw new Exception("traverse()方法入参异常:curNode和beforeNode不能为空" + nodeName);
		}
		if(nodeName.get("nextNode") != null 
				&& nodeCollections.get(nodeName.get("nextNode"))== null ){
			throw new Exception("节点"+ nodeName.get("nextNode") +"在节点集合中不存在");
		}
		String nextNodeName =  nodeName.get("nextNode") ;
		String curNodeName = nodeName.get("curNode") ;
		if( nextNodeName  == null){
			if(isSelectedNode(curNodeName, nodes)){
				record(inn, ret, curNodeName);
				this.checkOut(curNodeName, inn);
			}
			nodeName = backInDigraphForSeek(nodeCollections, nodeName);
			
		}else{
			if(isSelectedNode(nextNodeName, nodes)){
				this.checkIn(nextNodeName, inn);
			}
			nodeName = headInDigraphForSeek(nodeCollections, nodeName);
			
		}	
	 /**
	  * 如果不是起始"视野"，但是nextNode和curNode相同的，
	  * 说明在一个节点上可能存在包含自身的关系，这样的数据是异常数据
	  * 顺序不可调整至调用head()和back()的语句前面
	  */
		if(nodeName.get("curNode").equals(nodeName.get("nextNode")) &&
				!nodeName.get("curNode").equals(nodeName.get("beforeNode"))){
			int curRelIndex = (Integer) nodeCollections.get(nodeName.get("curNode")).get("curRelIndex") ;
			throw new Exception("节点参数异常:节点" + nodeName.get("curNode")+
					"的关系节点不能包含自身，在relList的第"+ 
					(curRelIndex + 1)+"元素上");
		}
		
		return nodeName ;
		
	}
	
	/**
	 * 
	 * 功能：判断节点是否为已选节点
	 * 作者：EugeneJao
	 * @param curNodeName
	 * @param nodes
	 * @return
	 */
	private boolean isSelectedNode(String curNodeName,List<String> nodes){
		
		boolean ret = false ;
		
		Iterator it = nodes.iterator() ;
		while(it.hasNext()){
			String tmpNodeName = (String) it.next() ;
			if(tmpNodeName.equals(curNodeName)){
				ret = true ;
				break ;
			}
		}
		
		return ret;
		
	}
	
	/**
	 * 
	 * 功能：将节点放入inn中，并进行相关操作
	 * 作者：EugeneJao
	 * @param curNodeName
	 * @param inn
	 */
	private void checkIn(String curNodeName , Map<String,Map<String,Object>> inn){
		
		/**
		 * 将已在inn中的节点的relList增加当前节点
		 */
		Set keySet = inn.entrySet();
		Iterator it = keySet.iterator() ;
				
		while(it.hasNext()){
			Entry tmpSet = (Entry) it.next() ;
			String tmpKey = (String) tmpSet.getKey();
			Map<String, Object> tmpNode = inn.get(tmpKey);
			Set<String> tmpList = (Set<String>) tmpNode.get("containNode");
			tmpList.add(curNodeName);			
			tmpNode.put("containNode", tmpList);
			inn.put(tmpKey, tmpNode);
		}
		
		/**
		 * 往inn中新增节点
		 */
		Map<String,Object> traverNode = new HashMap<String, Object>();
		Set<String> relList= new HashSet<String>();
		traverNode.put("nodeName",curNodeName);
		traverNode.put("containNode", relList);
		inn.put(curNodeName, traverNode) ;
		
	}
	
	/**
	 * 
	 * 功能：将已选节点从inn中删除
	 * 作者：EugeneJao
	 * @param curNodeName
	 * @param inn
	 */
	private void checkOut(String curNodeName , Map<String,Map<String,Object>> inn){
		
		inn.remove(curNodeName);
		
	}
	
	
	/** 功能：在有向图中前进至下一个节点
	* 作者：EugeneJao
	* @param nodeCollections
	* @param nodeName
	* @param inn
	* @return
	 * @throws Exception 
	**/
	@SuppressWarnings("unchecked")
	private Map<String,String> headInDigraphForSeek(Map<String,Map<String,Object>> nodeCollections , Map<String,String> nodeName) throws Exception{
		String  curNodeName = nodeName.get("nextNode") ; //传入参数的nextNode在本方法中即是当前节点
		String beforeNodeName = nodeName.get("curNode") ;//传入参数的curNode在本方法中即是前一节点
		Map<String,Object> curNode = nodeCollections.get(curNodeName);
		List<String> relList = (List<String>) curNode.get("relList") ;
		curNode.put("beforeNode",beforeNodeName) ;//传入参数的beforeNode在本方法中即是当前节点
		int curRelIndex = getNextNodeIndexInDigraphForSeek(curNode);
		/**
		 * 获取下一个前进的目标节点名称,当curRelIndex等于relList的长度时，
		 * 说明当前节点的所有关系节点都遍历完了,已无节点可以前进，只能后退
		 */
		String nextNodeName = null ;
		if(curRelIndex < relList.size()){
			nextNodeName = relList.get(curRelIndex) ; 
		}
	
	
	
		/**
		 * 更新当前节点信息
		 */
		curNode.put("curRelIndex", curRelIndex);//不能调整顺序值调用getNextNodeIndex()方法后面
		nodeCollections.put(curNodeName, curNode);
		/**
		 * 更新nodeName信息
		 */
		nodeName.put("nextNode", nextNodeName);
		nodeName.put("curNode", curNodeName);
		nodeName.put("beforeNode", beforeNodeName);
	
		return nodeName;
	}

	/**
	* 
	* 功能：在无向图中后退至之前的节点
	* 作者：EugeneJao
	* @param nodeCollections
	* @param nodeName
	* @return
	 * @throws Exception 
	*/
	private Map<String,String> backInDigraphForSeek(Map<String,Map<String,Object>> nodeCollections , Map<String, String> nodeName) throws Exception{
		
		/**
		 * 节点后退，说明遍历完当前节点的所有子孙节点后，依然没有闭环
		 * 所以先更新当前节点信息的isFroze字段为true
		 * 在多个父节点的情况下，通过isFrozen字段来区分之前通过另一父节点对改节点的遍历
		 * 同时也通过这个属性介绍算法运算的复杂度
		 */
		String  curNodeName = nodeName.get("curNode");
		Map<String,Object> curNode = nodeCollections.get(curNodeName);
		curNode.put("isFrozen", true);
		
		/**
		 * 更新完Frozen属性后，做后退操作
		 */
		curNodeName = nodeName.get("beforeNode") ; //传入参数的beforeNode在后退操作中即是当前节点		
		curNode = nodeCollections.get(curNodeName);
		List<String> relList = (List<String>) curNode.get("relList") ;
		String beforeNodeName = (String) curNode.get("beforeNode");
		/**
		 * 先更新当前节点beforeNode信息，因为后面要用
		 */
		curNode.put("beforeNode", beforeNodeName);//不能调整顺序值调用getNextNodeIndex()方法后面
		
		int curRelIndex = getNextNodeIndexInDigraphForSeek(curNode);
		/**
		 * 获取下一个前进的目标节点名称,当curRelIndex等于relList的长度时，
		 * 说明当前节点的所有关系节点都遍历完了,已无节点可以前进，只能后退
		 */
		String nextNodeName = null ;
		if(curRelIndex < relList.size()){
			nextNodeName = relList.get(curRelIndex) ; 
		}
		
		/**
		 * 更新当前节点信息
		 */
		curNode.put("curRelIndex", curRelIndex);//不能调整顺序值调用getNextNodeIndex()方法前面
		
		nodeCollections.put(curNodeName, curNode);
		/**
		 * 更新nodeName信息
		 */
		nodeName.put("nextNode", nextNodeName);
		nodeName.put("curNode", curNodeName);
		nodeName.put("beforeNode",beforeNodeName) ;
		
		
		return nodeName;
	}
	
	/**
	 * 
	 * 功能：将即将从inn中请出的node放入ret中
	 * 作者：EugeneJao
	 * @param inn
	 * @param ret
	 * @param curNodeName
	 */
	private void record(Map<String,Map<String,Object>> inn , Map<String,Map<String,Object>> ret , String curNodeName){
		Map<String,Object> curNode = inn.get(curNodeName);
		ret.put(curNodeName, curNode);
	}
	
	/**
	 * 
	 * 功能：在有向图中获取下一节点名称在relList里的索引值
	 * 作者：EugeneJao
	 * @param curNode
	 * @return
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private int getNextNodeIndexInDigraphForSeek(Map<String,Object> curNode) throws Exception{
		if(!(curNode.get("isFrozen") instanceof Boolean)){
			throw new Exception("节点"+ curNode.get("nodeName") +
					"参数类型异常:isFrozen合法类型为布尔类型，isFrozen:"+ curNode.get("isFrozen"));
		}
		/**
		 * 如果当前节点状态为冻结，怎么说明它与它的子节点之前都被遍历过了，
		 * 为了让这次能够再次遍历，设置状态为非冻结状态，同时返回索引值0
		 */
		if((Boolean) curNode.get("isFrozen")){
			
			curNode.put("isFrozen", false);			
			return 0 ;
		}
		
		List<String> relList = (List<String>) curNode.get("relList") ;
		int curRelIndex = (Integer) curNode.get("curRelIndex") ;
		String beforeNodeName = (String) curNode.get("beforeNode");		
		curRelIndex ++ ;
		/**
		 * 如果curRelIndex大于relList的大小
		 * 则说明当前节点的关系节点全都遍历过了,curRelIndex赋值为relList的大小，
		 * 即说明当前节点的关系节点全都遍历过了，不能前进了，只能后退
		 */
		if(curRelIndex > relList.size()){
			curRelIndex = relList.size() ;
		}
		return curRelIndex ;
	}


测试代码如下：
public static void main(String [] args) throws Exception{
		
		Map<String,Map<String,Object>> nodeCollections = new HashMap<String, Map<String,Object>>() ;
		
		Map<String,Object> node_1 = new HashMap<String, Object>() ;		
		String nodeName_1 = "1" ; 		
		List<String> relList_1 = new ArrayList<String>() ;	
		relList_1.add("2");
		relList_1.add("3");
		int curRelIndex_1 = -1 ;		
		String beforeNode_1 = null ;
		node_1.put("nodeName", nodeName_1) ;
		node_1.put("curRelIndex", curRelIndex_1) ;
		node_1.put("beforeNode", beforeNode_1) ;
		node_1.put("relList", relList_1) ;
		node_1.put("isFrozen", false);
		node_1.put("isRoot", false);
		
		Map<String,Object> node_2 = new HashMap<String, Object>() ;		
		String nodeName_2 = "2" ; 		
		List<String> relList_2 = new ArrayList<String>() ;	
		relList_2.add("4");
		int curRelIndex_2 = -1 ;		
		String beforeNode_2 = null ;
		node_2.put("nodeName", nodeName_2) ;
		node_2.put("curRelIndex", curRelIndex_2) ;
		node_2.put("beforeNode", beforeNode_2) ;
		node_2.put("relList", relList_2) ;
		node_2.put("isFrozen", false);
		node_2.put("isRoot", false);
		
		Map<String,Object> node_3 = new HashMap<String, Object>() ;		
		String nodeName_3 = "3" ; 		
		List<String> relList_3 = new ArrayList<String>() ;	
		relList_3.add("4");
		
		int curRelIndex_3 = -1 ;		
		String beforeNode_3 = null ;
		node_3.put("nodeName", nodeName_3) ;
		node_3.put("curRelIndex", curRelIndex_3) ;
		node_3.put("beforeNode", beforeNode_3) ;
		node_3.put("relList", relList_3) ;
		node_3.put("isFrozen", false);
		node_3.put("isRoot", false);
		
		
		Map<String,Object> node_4 = new HashMap<String, Object>() ;		
		String nodeName_4 = "4" ; 		
		List<String> relList_4 = new ArrayList<String>() ;	
		relList_4.add("5");
		relList_4.add("6");
		int curRelIndex_4 = -1 ;		
		String beforeNode_4 = null ;
		node_4.put("nodeName", nodeName_4) ;
		node_4.put("curRelIndex", curRelIndex_4) ;
		node_4.put("beforeNode", beforeNode_4) ;
		node_4.put("relList", relList_4) ;
		node_4.put("isFrozen", false);
		node_4.put("isRoot", false);
		
		
		Map<String,Object> node_5 = new HashMap<String, Object>() ;		
		String nodeName_5 = "5" ; 		
		List<String> relList_5 = new ArrayList<String>() ;	
		int curRelIndex_5 = -1 ;		
		String beforeNode_5 = null ;
		node_5.put("nodeName", nodeName_5) ;
		node_5.put("curRelIndex", curRelIndex_5) ;
		node_5.put("beforeNode", beforeNode_5) ;
		node_5.put("relList", relList_5) ;
		node_5.put("isFrozen", false);
		node_5.put("isRoot", false);
		
		Map<String,Object> node_6 = new HashMap<String, Object>() ;		
		String nodeName_6 = "6" ; 		
		List<String> relList_6 = new ArrayList<String>() ;	
		relList_6.add("7");
		int curRelIndex_6 = -1 ;		
		String beforeNode_6 = null ;
		node_6.put("nodeName", nodeName_6) ;
		node_6.put("curRelIndex", curRelIndex_6) ;
		node_6.put("beforeNode", beforeNode_6) ;
		node_6.put("relList", relList_6) ;
		node_6.put("isFrozen", false);
		node_6.put("isRoot", false);
		
		
		
		Map<String,Object> node_7 = new HashMap<String, Object>() ;		
		String nodeName_7 = "7" ; 		
		List<String> relList_7 = new ArrayList<String>() ;	
		relList_7.add("5");
		int curRelIndex_7 = -1 ;		
		String beforeNode_7 = null ;
		node_7.put("nodeName", nodeName_7) ;
		node_7.put("curRelIndex", curRelIndex_7) ;
		node_7.put("beforeNode", beforeNode_7) ;
		node_7.put("relList", relList_7) ;
		node_7.put("isFrozen", false);
		node_7.put("isRoot", false);
		
		nodeCollections.put("1",node_1 );
		nodeCollections.put("2",node_2 );
		nodeCollections.put("3",node_3 );
		nodeCollections.put("4",node_4 );
		nodeCollections.put("5",node_5 );
		nodeCollections.put("6",node_6 );
		nodeCollections.put("7",node_7 );
		
		GraphAnalysis analysis = new GraphAnalysis() ;
		long start = System.currentTimeMillis();
			/*boolean result = analysis.isContainLoop(nodeCollections);*/
		List<String> nodes = new ArrayList<String>();
		nodes.add("1");
		nodes.add("4");
		nodes.add("7");
		nodes.add("5");
		Map<String,Map<String,Object>> ret = analysis.seekRelation(nodeCollections, nodes);
		System.out.println(ret);
		/*boolean result = analysis.isContainLoopInDigraph(nodeCollections);
		System.out.println(result);*/
		long end = System.currentTimeMillis();
		
		System.out.println("耗时:" + (end - start) );
	}


如有BUG，欢迎大家提出，谢谢！

情人之间对未来有承诺的味道！
 

情人关系走向了，困境的睡姿！
 

互相信任的睡姿!
 

女人的一切都要依赖男人的睡姿！
 





你为什么找不到女朋友

你为什么交不到女朋友？





爱情安全型测试

好不容易有了恋情，本以为就是幸福的开始，...





宗教态度测试

你会定期去做礼拜吗？你会坚持每天的祷告吗...





你有没有当少奶奶的命


一入豪门深似海？





老情人的睡姿!
 

新情人，热恋情人的睡姿！
 

情侣双方工作很累,需要休息,正常的睡姿!
 

男方想抛弃女方的睡姿！
 

情人闹了点小别扭的睡姿！
 

呵护的睡姿，多见于老男人对小情人的睡姿！