`
shlei
  • 浏览: 291460 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

仿IBM-BPM Editor实现的WorkFlowEditor

IBMWorkflowFlashJ# 
阅读更多
    在网上搜了一些例子，找了一大队资料，终于把workFlowEditor做得差不多了，这是一个类似IBM-BPM Editor的工作流编辑器，现还有一些功能没实现，现将部分代码贴在此，有需要的朋友可以交流，拍砖，哈哈。

上图：


节点间的连线重绘： 
package com
{
	import flash.geom.Point;
	
	public class RefreshLine
	{
		/** 和节点相关的线条的数组 **/
		public var lineList:Array = [];
		
		public var width:Number;
		public var height:Number;
		public var lineFlag:LineLag;
		public var line:Line;
		public var node:Nodes;
		private var isFromNode:Boolean=false;
		private var num1:int=0;		//开始节点，箭头右方向，连线数累加
		private var num2:int=0;		//开始节点，箭头左方向，连线数累加
		private var num3:int=0;		//开始节点，箭头上方向，连线数累加
		private var num4:int=0;		//开始节点，箭头下方向，连线数累加
		private var numA:int=0;		//结束节点，箭头右方向，连线数累加
		private var numB:int=0;		//结束节点，箭头左方向，连线数累加
		private var numC:int=0;		//结束节点，箭头上方向，连线数累加
		private var numD:int=0;		//结束节点，箭头下方向，连线数累加
		private var startX:int;
		private var startY:int;
		private var endX:int;
		private var endY:int;
		
		
		public function RefreshLine(node:Nodes)
		{
			this.node=node;
			lineList=node.lineList;
		}
		
		/**
		 * 重绘节点上的连线
		 * */
		public function getAspectArr():void{
			for(var j:int = 0; j < lineList.length; j++){
				lineFlag = lineList[j];
				line = lineFlag.line;
				
				switch(line.aspect){
					case 1:
						if(line.fromNode==node)
							num1++;
						else
							numA++;
						break;
					case 2:
						if(line.fromNode==node)
							num2++;
						else
							numB++;
						break;
					case 3:
						if(line.fromNode==node)
							num3++;
						else
							numC++;
						break;
					case 4:
						if(line.fromNode==node)
							num4++;
						else
							numD++;
						break;
				}
			}
		}
		
		public function refreshLine():void{
			var isHead:Boolean;
			var startNO:int=0;	//指向开始节点的连线的条数
			var endNO:int=0;	//指向结束节点的连线的条数
			
			width=node.width;
			height=node.height;
			getAspectArr();
			
			for(var i:int = 0; i < lineList.length; i++){
				startX = node.x;
				startY = node.y;
				endX = node.x;
				endY = node.y;
				lineFlag = lineList[i];
				line = lineFlag.line;
				isHead = lineFlag.isHead;
				
				if(line.fromNode==node){
					isFromNode=true;
					startNO++;
				}else{
					endNO++;
				}
				
				switch(node.type){
					case Nodes.NODE:
					case Nodes.EMAIL:
					case Nodes.CLOCK:
					case Nodes.ENDNODE:
						circleNodePosition(startNO,endNO);
						break;
					case Nodes.RECT:
						rectNodePosition(startNO,endNO);
						break;
					case Nodes.BRECT:
						rectNodePosition(startNO,endNO);
						break;
					case Nodes.DIAMOND:
						diamondNodePosition(startNO,endNO);
						break;
				}
				/**
				 * 如果是连线箭头所指的，则重设线条开始位置
				 * 如果不是，则重设连线结束
				 **/ 
				if(isHead)
					line.startPoint = new Point(startX,startY);
				else
					line.endPoint = new Point(endX,endY); 
				
				line.drawLine(line.aspect);
			}
			num1=0;
			num2=0;
			num3=0;
			num4=0;
			numA=0;
			numB=0;
			numC=0;
			numD=0;
		}
		
		private function circleNodePosition(startNO:int,endNO:int):void{
			switch(line.aspect){
				case 1:
					//箭头向右
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.y<line.toNode.y){
								startY+=Nodes.CIRCLE_RADIUS*2+1;
							}else{
								startY-=1;
							}
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num1+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=13;
							startY+=Nodes.CIRCLE_RADIUS*2/(num1+1)*(startNO);
							break;
						default:
							startX+=width-15;
							startY+=Nodes.CIRCLE_RADIUS*2/(num1+1)*(startNO);
							break;
					}
					endX+=15;
					endY+=Nodes.CIRCLE_RADIUS*2/(numA+1)*(endNO);
					break;
				case 2:
					//箭头向左
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.y<line.toNode.y){
								startY+=Nodes.CIRCLE_RADIUS*2+1;
							}else{
								startY-=1;
							}
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num2+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width-15;
							startY+=Nodes.CIRCLE_RADIUS*2/(num2+1)*(startNO);
							break;
						default:
							startX+=13;
							startY+=Nodes.CIRCLE_RADIUS*2/(num2+1)*(startNO);
							break;
					}
					endX+=width-13;
					endY+=Nodes.CIRCLE_RADIUS*2/(numB+1)*(endNO);
					break;
				case 3:
					//箭头向上
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.x<line.toNode.x){
								startX+=width-15;
							}else{
								startX+=13;
							}
							startY+=Nodes.CIRCLE_RADIUS*2/(num3+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num3+1)*(startNO);
							startY+=Nodes.CIRCLE_RADIUS*2+1;
							break;
						default:
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num3+1)*(startNO);
							startY-=1;
							break;
					}
					endX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(numC+1)*(endNO);
					endY+=Nodes.CIRCLE_RADIUS*2+3;
					break;
				case 4:
					//箭头向下
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.x<line.toNode.x){
								startX+=width-15;
							}else{
								startX+=13;
							}
							startY+=Nodes.CIRCLE_RADIUS*2/(num4+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num4+1)*(startNO);
							startY-=1;
							break;
						default:
							startX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(num4+1)*(startNO);
							startY+=Nodes.CIRCLE_RADIUS*2+1;
							break;
					}
					endX+=width/2-Nodes.CIRCLE_RADIUS+Nodes.CIRCLE_RADIUS*2/(numD+1)*(endNO);
					endY-=2;
					break;
			}
		}
		
		private function rectNodePosition(startNO:int,endNO:int):void{
			switch(line.aspect){
				case 1:
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.y<line.toNode.y){
								startY+=height+2;
							}else{
								startY-=0;
							}
							startX+=width/(num1+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX-=0;
							startY+=height/(num1+1)*(startNO);
							break;
						default:
							startX+=width;
							startY+=height/(num1+1)*(startNO);
							break;
					}
					endX-=2;
					endY+=height/(numA+1)*(endNO);
					break;
				case 2:
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.y<line.toNode.y){
								startY+=height+2;
							}else{
								startY-=0;
							}
							startX+=width/(num2+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width;
							startY+=height/(num2+1)*(startNO);
							break;
						default:
							startX-=0;
							startY+=height/(num2+1)*(startNO);
							break;
					}
					endX+=width+2;
					endY+=height/(numB+1)*(endNO);
					break;
				case 3:
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.x<line.toNode.x){
								startX+=width;
							}else{
								startX-=0;
							}
							startY+=height/(num3+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width/(num3+1)*(startNO);
							startY+=height+2;
							break;
						default:
							startX+=width/(num3+1)*(startNO);
							startY-=0;
							break;
					}
					endX+=width/(numC+1)*(endNO);
					endY+=height+3;
					break;
				case 4:
					switch(line.lineStyle){
						case line.lineStyleArr[1]:
							if(line.fromNode.x<line.toNode.x){
								startX+=width;
							}else{
								startX-=0;
							}
							startY+=height/(num4+1)*(startNO);
							break;
						case line.lineStyleArr[2]:
							startX+=width/(num4+1)*(startNO);
							startY-=0;
							break;
						default:
							startX+=width/(num4+1)*(startNO);
							startY+=height+2;
							break;
					}
					endX+=width/(numD+1)*(endNO);
					endY-=1;
					break;
			}
		}
		
		private function diamondNodePosition(startNO:int,endNO:int):void{
			switch(line.aspect){
				case 1:
					if((num1<=1 && line.fromNode==node) || (numA<=1 && line.toNode==node)){
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.y<line.toNode.y){
									startY+=Nodes.DIAMOND_BORDER;
								}else{
									startY-=0;
								}
								startX+=width/2;
								break;
							case line.lineStyleArr[2]:
								startX+=4;
								startY+=Nodes.DIAMOND_BORDER/(num1+1)*(startNO);
								break;
							default:
								startX+=Nodes.DIAMOND_BORDER+6;
								startY+=Nodes.DIAMOND_BORDER/2;
								break;
						}
						endX+=3;
						endY+=Nodes.DIAMOND_BORDER/2;
					}else{
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.y<line.toNode.y){
									startY+=Nodes.DIAMOND_BORDER-13;
								}else{
									startY+=13;
								}
								startX+=width/(num1+1)*(startNO);
								break;
							case line.lineStyleArr[2]:
								startX+=(width-Nodes.DIAMOND_BORDER)/2+10;
								startY+=Nodes.DIAMOND_BORDER/(num1+1)*(startNO);
								break;
							default:
								startX+=Nodes.DIAMOND_BORDER-6;
								startY+=Nodes.DIAMOND_BORDER/(num1+1)*(startNO);
								break;
						}
						endY+=Nodes.DIAMOND_BORDER/(numA+1)*(endNO);
						
						if((num1==3 && startNO==2) || (numA==3 && endNO==2)){
							endX+=3;
						}else{
							endX+=15;
						}
					}
					break;
				case 2:
					if((num2<=1 && line.fromNode==node) || (numB<=1 && line.toNode==node)){
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.y<line.toNode.y){
									startY+=Nodes.DIAMOND_BORDER;
								}else{
									startY-=0;
								}
								startX+=width/2;
								break;
							case line.lineStyleArr[2]:
								startX+=Nodes.DIAMOND_BORDER+6;
								startY+=Nodes.DIAMOND_BORDER/(num2+1)*(startNO);
								break;
							default:
								startX+=4;
								startY+=Nodes.DIAMOND_BORDER/2;
								break;
						}
						endX+=Nodes.DIAMOND_BORDER+6;
						endY+=Nodes.DIAMOND_BORDER/2;
					}else{
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.y<line.toNode.y){
									startY+=Nodes.DIAMOND_BORDER-13;
								}else{
									startY+=13;
								}
								startX+=width/(num2+1)*(startNO);
								break;
							case line.lineStyleArr[2]:
								startX+=Nodes.DIAMOND_BORDER-6;
								startY+=Nodes.DIAMOND_BORDER/(num2+1)*(startNO);
								break;
							default:
								startX+=(width-Nodes.DIAMOND_BORDER)/2+13;
								startY+=Nodes.DIAMOND_BORDER/(num2+1)*(startNO);
								break;
						}
						endY+=Nodes.DIAMOND_BORDER/(numB+1)*(endNO);
						
						if((num2==3 && startNO==2) || (numB==3 && endNO==2)){
							endX+=Nodes.DIAMOND_BORDER+7;
						}else{
							endX+=Nodes.DIAMOND_BORDER-4;
						}
					}
					break;
				case 3:
					if((num3<=1 && line.fromNode==node) || (numC<=1 && line.toNode==node)){
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.x<line.toNode.x){
									startX+=Nodes.DIAMOND_BORDER+6;
								}else{
									startX+=4;
								}
								startY+=Nodes.DIAMOND_BORDER/2;
								break;
							case line.lineStyleArr[2]:
								startX+=width/(num3+1)*(startNO);
								startY+=Nodes.DIAMOND_BORDER;
								break;
							default:
								startX+=width/2;
								startY-=0;
								break;
						}
						endX+=width/2;
						endY+=Nodes.DIAMOND_BORDER+2;
					}else{
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.x<line.toNode.x){
									startX+=Nodes.DIAMOND_BORDER-13;
								}else{
									startX+=15;
								}
								startY+=Nodes.DIAMOND_BORDER/(num3+1)*(startNO);
								break;
							case line.lineStyleArr[2]:
								startX+=width/(num3+1)*(startNO);
								startY+=Nodes.DIAMOND_BORDER-13;
								break;
							default:
								startX+=width/(num3+1)*(startNO);
								startY+=13;
								break;
						}
						endX+=width/(numC+1)*(endNO);
						if((num3==3 && startNO==2) || (numC==3 && endNO==2)){
							endY+=Nodes.DIAMOND_BORDER+2;
						}else{
							endY+=Nodes.DIAMOND_BORDER-11;
						}
					}
					break;
				case 4:
					if((num4<=1 && line.fromNode==node) || (numD<=1 && line.toNode==node)){
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.x<line.toNode.x){
									startX+=Nodes.DIAMOND_BORDER+6;
								}else{
									startX+=4;
								}
								startY+=Nodes.DIAMOND_BORDER/2;
								break;
							case line.lineStyleArr[2]:
								startX+=width/(num4+1)*(startNO);
								startY-=0;
								break;
							default:
								startX+=width/2;
								startY+=Nodes.DIAMOND_BORDER;
								break;
						}
						endX+=width/2;
						endY-=1;
					}else{
						switch(line.lineStyle){
							case line.lineStyleArr[1]:
								if(line.fromNode.x<line.toNode.x){
									startX+=Nodes.DIAMOND_BORDER-13;
								}else{
									startX+=15;
								}
								startY+=Nodes.DIAMOND_BORDER/(num4+1)*(startNO);
								break;
							case line.lineStyleArr[2]:
								startX+=width/(num4+1)*(startNO);
								startY+=13;
								break;
							default:
								startX+=width/(num4+1)*(startNO);
								startY+=Nodes.DIAMOND_BORDER-13;
								break;
						}
						endX+=width/(numD+1)*(endNO);
						if((num4==3 && startNO==2) || (numD==3 && endNO==2)){
							endY-=1;
						}else{
							endY+=11;
						}
					}
					break;
			}
		}
		
	}
}


键盘事件类： 
package com
{
	import flash.events.KeyboardEvent;
	import flash.events.MouseEvent;
	
	import mx.core.UITextField;
	
	import net.L4cd.iTrace;
	
	public class WFKeyboard
	{
		private var node:Nodes;
		private var line:Line;
		private var workFlow:CusWorkFlow;
		private var o:Object;
		/** CusWorkFlow对象的放大/缩小参数 **/
		private var scaleNO:Number=.2;
		/** 封装连线的对象 **/
		private var lineLag1:LineLag;
		
		public var trace:Function = iTrace.init;
		
		public function WFKeyboard()
		{
			
		}
		
		/** 选择键盘按键ASCII值 **/
		public function chooseKey(e:KeyboardEvent,mouseE:MouseEvent):void {
			o=getObjects(mouseE);
			node=o.node as Nodes;
			line=o.line as Line;
			workFlow=o.workFlow as CusWorkFlow;
			switch(e.keyCode){
				case 8:
				case 46:
					deleteNode(node,line,workFlow);
					break;
				case 65:
					if(!e.ctrlKey)return;
					
					break;
				case 107:
					if(!e.ctrlKey)return;
					workFlow.scaleX+=scaleNO;//放大CusWorkFlow对象
					workFlow.scaleY+=scaleNO;
					break;
				case 109:
					if(!e.ctrlKey)return;
					workFlow.scaleX-=scaleNO;//缩小CusWorkFlow对象
					workFlow.scaleY-=scaleNO;
					break;
			}
		}
		
		/** 删除节点或连线 **/
		private function deleteNode(node:Nodes,line:Line,workFlow:CusWorkFlow):void {
			if(!workFlow)return;
			
			if(node){
				var num:int=node.lineList.length;
				for(var i:int=0;i<num;i++){
					var lineLag:LineLag=node.lineList[i];
					workFlow.removeChild(lineLag.line);
					
					if(node==lineLag.line.fromNode){
						for(var j:int=0;j<lineLag.line.toNode.lineList.length;j++){
							lineLag1=lineLag.line.toNode.lineList[j] as LineLag;
							if(node==lineLag1.line.fromNode){
								lineLag.line.toNode.lineList.splice(j,1);
							}
						}
					}else{
						for(var k:int=0;k<lineLag.line.fromNode.lineList.length;k++){
							lineLag1=lineLag.line.fromNode.lineList[k] as LineLag;
							if(node==lineLag1.line.toNode){
								lineLag.line.fromNode.lineList.splice(k,1);
							}
						}
					}
				}
				
				workFlow.removeChild(node);
			}else if(line){
				for(var m:int=0;m<line.toNode.lineList.length;m++){
					lineLag1=line.toNode.lineList[m] as LineLag;
					if(line==lineLag1.line){
						line.toNode.lineList.splice(m,1);
						break;
					}
				}
				
				for(var n:int=0;n<line.fromNode.lineList.length;n++){
					lineLag1=line.fromNode.lineList[n] as LineLag;
					if(line==lineLag1.line){
						line.fromNode.lineList.splice(n,1);
					}
				}
				workFlow.removeChild(line);
			}
		}
		
		/** 重画节点边框，表示选中或非选中 **/
		public function reDrawNode(map:Nodes):void{
			switch(map.type){
				case Nodes.NODE:
					map.drawNode();
					break;
				case Nodes.DOC:
					map.drawDoc();
					break;
				case Nodes.EMAIL:
					map.drawEmail();
					break;
				case Nodes.RECT:
					map.drawRect();
					break;
				case Nodes.BRECT:
					map.drawBRect();
					break;
				case Nodes.DIAMOND:
					map.drawDiamond();
					break;
				case Nodes.CLOCK:
					map.drawClock();
					break;
				case Nodes.ENDNODE:
					map.drawEndNode();
					break;
				case Nodes.LEFTDASHED:
					map.drawDashed();
					break;
				case Nodes.RIGHTDASHED:
					map.drawDashed2();
					break;
			}
		}
		
		/** 返回鼠标选中的对象 **/
		private function getObjects(e:MouseEvent):Object{
			o=new Object();
			if(e.target is UITextField){
				o.node=e.target.parent.parent as Nodes;
				o.workFlow=e.target.parent.parent.parent as CusWorkFlow;
			}else if(e.target is Nodes){
				o.node=e.target as Nodes;
				o.workFlow=e.target.parent as CusWorkFlow;
			}else if(e.target is CusWorkFlow){
				o.workFlow=e.target as CusWorkFlow;
			}else if(e.target is Line){
				o.line=e.target as Line;
				o.workFlow=e.target.parent as CusWorkFlow;
			}
			return o;
		}
	}
}


  • 大小: 88 KB
6
顶
0
踩
分享到：
| 仿IBM-BPM Monitor实现的demo
评论
13 楼 jcl860 2012-09-14  
兄台：左边面板是图片，还是用mxml画出来的图形？
12 楼 jcl860 2012-09-05  
兄弟，能把mxml代码贴上看看不，主要是画不出界面啊。
11 楼 shlei 2012-08-31  
jcl860 写道
兄弟，你有联系方式没有，请给发一下。我的邮箱:317902593@qq.com。

这里有，自己下载吧，http://www.ibm.com/developerworks/cn/downloads/ws/elixir/
10 楼 jcl860 2012-08-31  
兄弟，你有联系方式没有，请给发一下。我的邮箱:317902593@qq.com。
9 楼 shlei 2012-08-30  
jcl860 写道
兄弟, import com.ibm.ilog.elixir.diagram.Graph;缺这些东西啊，这些东西报错了，咋整呢?

你这个是用的ilog组件，需要导入ilog的swc库文件，
8 楼 jcl860 2012-08-30  
兄弟, import com.ibm.ilog.elixir.diagram.Graph;缺这些东西啊，这些东西报错了，咋整呢?
7 楼 421081646 2012-08-08  
挺好的，学习了
6 楼 shlei 2011-11-11  
a0409028 写道
连线是怎么实现的有弧度，据天代码是那块？，感谢 了。

二次贝塞尔曲线，查资料吧，
5 楼 a0409028 2011-11-11  
连线是怎么实现的有弧度，据天代码是那块？，感谢 了。
4 楼 shlei 2011-10-19  
a0409028 写道
能不能共享一下，页面源码

抱歉，这已经是商业产品了，
3 楼 a0409028 2011-10-19  
能不能共享一下，页面源码
2 楼 debbykindom 2011-09-16  
，强大，希望有机会再和兄台深入交流。
1 楼 tree_161219 2011-03-29  
写的很不错呢！
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    福兴讯V587对讲机写频，调频软件 福摩斯特V587

    福兴讯V587对讲机写频，调频软件。福摩斯特V587对讲机写频，调频

    uni-helper_vite-plugin-uni-tai_1742854282.zip

    app开发

    LangChain框架详解：大语言模型应用开发的核心模块与实践

    内容概要：本文介绍了LangChain这一开源框架，它专为开发基于大型语言模型（LLM）的应用程序而设计。文章阐述了LangChain的核心理念、架构组成及其重要性。LangChain通过模块化设计解决了大模型应用开发中的效率低下和局限性问题，提供了标准化的接口和丰富的抽象层，使开发者能够轻松接入不同大模型并构建高效的应用程序。文中详细讲解了几个关键模块，包括Model I/O、Retrieval、Chains、Memory、Agents和Callbacks，以及如何安装和使用LangChain进行开发。此外，还展示了具体的代码示例，如如何调用OpenAI的API、构建LLMChain链路、设置回调机制和实现对话记忆功能。 适合人群：对大语言模型有一定了解并且有兴趣开发基于LLM的应用程序的研发人员和技术爱好者。 使用场景及目标：①帮助开发者快速掌握LangChain的基本概念和使用方法；②提供实用的代码示例，便于开发者实际操作；③解释如何通过LangChain克服大模型应用开发中的常见难题，如模型差异、输出不稳定等。 阅读建议：鉴于LangChain涉及较多的专业术语和技术细节，建议读者在阅读时结合官方文档和示例代码一起学习，尤其是对于核心模块的理解和实践。同时，关注GitHub上的最新版本更新，以获取最新的特性和改进。

    网络伴侣 iCompanion 2.1

    网络伴侣 iCompanion 2.1 网络计费软件，功能全面，支持ISDN

    移动开发_Flutter_简约聊天_纸聊APP_1742846962.zip

    app开发

    《基于YOLOv8的交通事故自动报警系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

    《基于YOLOv8的八段锦练习指导系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

    前端开发_UniApp_云开发_JsSdk_全端适配实战讲解_1742852088.zip

    app开发

    移动开发_Flutter_轮子推荐_开发效率提升_1742851671.zip

    移动开发_Flutter_轮子推荐_开发效率提升_1742851671.zip

    往复活塞杆密封件热弹流润滑仿真：Python实现与解析（复现论文，含详细可运行代码及解释）

    内容概要：本文详细介绍了往复活塞杆密封件在瞬态条件下热弹流润滑仿真的Python实现。首先定义了几何、材料和工况参数，然后分别构建了流体力学、热力学和固体力学模型。流体力学模型使用有限差分法求解瞬态雷诺方程，热力学模型考虑了温度和压力对粘度的影响，固体力学模型则采用了Mooney-Rivlin超弹性模型和Prony级数描述的粘弹性松弛。最后通过耦合求解实现了整个系统的时间积分，并绘制了液膜厚度和压力分布图。文中还讨论了模型的特点、简化假设以及扩展建议。 适合人群：机械工程领域的研究人员和技术人员，尤其是对密封件性能优化感兴趣的从业者。 使用场景及目标：适用于研究往复活塞杆密封件的工作机理及其在不同工况下的表现，帮助工程师理解和预测密封件的动态特性，从而改进设计和选材。 其他说明：该实现基于论文中的理论框架，但在实际应用时可能需要进一步调整和完善。

    人人商城V3-3.2.1版本.zip 亲测能用

    人人商城V3-3.2.1版本.zip 亲测能用

    《基于YOLOv8的灯光设备监测系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

    Java面向对象编程，出现的示例代码

    Java面向对象编程，出现的示例代码

    蓝桥杯python相关资源，真题，蓝桥杯，蓝桥杯Python练习系统题库，蓝桥杯Python练习系统题库

    蓝桥杯python，蓝桥杯python相关资源，真题，蓝桥杯，蓝桥杯Python练习系统题库，蓝桥杯Python练习系统题库

    fsfzdgdfrgbzgr

    rgrgdfsegfasgrsredgf

    《基于YOLOv8的冲浪运动分析系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

    Lotus Notes 4.65

    Lotus Notes 4.65 是 IBM 旗下早期版本的企业级协作平台，主要面向办公自动化和非结构化数据管理领域。以下为综合信息整理： 一、版本背景与定位 核心架构 Lotus Notes 4.65 属于客户端-服务器架构的早期版本，其服务器端为 Lotus Domino18。 客户端功能：集成电子邮件、日历、联系人管理、文档数据库访问16。 服务器功能：支持分布式文档存储、跨平台数据同步及安全权限管理18。 技术特性 数据库技术：采用非结构化文档数据库，支持表单、视图、代理等自定义数据管理工具68。 工作流引擎：内置开发环境（Domino Designer），可定制审批流程、文档跟踪等企业级应用18。 跨平台兼容性：支持 Windows 95/98、NT 等早期操作系统，依赖 TCP/IP 协议实现网络通信25。

    Go语言入门指南：从基础语法到并发编程及错误处理

    内容概要：本文档详细介绍了Go语言的基础知识及其特性，旨在帮助初学者快速上手并掌握这门语言。首先概述了Go语言的特点，包括简洁高效的语法、强大的并发模型、跨平台支持以及丰富的标准库。接着逐步讲解了环境安装、基础语法、控制结构、集合类型、函数定义、结构体与方法、并发编程、错误处理等方面的内容。最后提供了包管理和学习资源的推荐，鼓励读者通过实战项目进一步提升技能。 适合人群：对编程有一定兴趣但尚未接触过Go语言的学习者，尤其是希望快速掌握一门高效并发编程语言的开发者。 使用场景及目标：①作为新手教程，帮助读者建立对Go语言的基本认识；②提供详细的语法指导，使读者能够独立完成简单的程序编写；③介绍并发编程和错误处理机制，培养解决实际问题的能力。 阅读建议：建议读者跟随文档内容进行实践操作，在理解和记忆的基础上多做练习，同时利用提供的学习资源加深理解。

Magicbox
Global site tag (gtag.js) - Google Analytics