diff --git a/src/jlmap3d/edit/connect/initDataSave.js b/src/jlmap3d/edit/connect/initDataSave.js
new file mode 100644
index 000000000..755c4fc4b
--- /dev/null
+++ b/src/jlmap3d/edit/connect/initDataSave.js
@@ -0,0 +1,156 @@
+//import request from '@/utils/request';
+
+export function initDataSave(data) {
+  console.log(data);
+    let postmap = {
+        id:data.mapdata.id,
+        mapId:data.mapdata.mapId,
+        assets:"null",
+        sections:"null",
+        signals:"null",
+        trains:"null",
+        stands:"null",
+        switchs:"null"
+    };
+
+    if(data.mapdata.sectionlist.sections== undefined){
+      return postmap;
+    }
+
+
+    if(data == undefined){
+
+      return postmap;
+    }else{
+
+      let models = data.assetManager;
+      console.log(data.assetManager);
+      postmap.assets = JSON.stringify(models);
+
+
+      //section隧道
+      let sections = [];
+      // console.log(data.mapdata.sectionlist.sections.datalist);
+      for(let i in data.mapdata.sectionlist.sections.datalist){
+        console.log(data.mapdata.sectionlist.sections.datalist[i].mesh.railpoint);
+        let section = {
+          // uuid:data.mapdata.sectionlist.sections.modellist[i].uuid,
+          code:data.mapdata.sectionlist.sections.datalist[i].code,
+          name:data.mapdata.sectionlist.sections.datalist[i].name,
+          lengthFact:data.mapdata.sectionlist.sections.datalist[i].mesh.lengthFact,
+          standTrack:data.mapdata.sectionlist.sections.datalist[i].standTrack,
+          rp:data.mapdata.sectionlist.sections.datalist[i].rp,
+          lp:data.mapdata.sectionlist.sections.datalist[i].lp,
+          railpoint:data.mapdata.sectionlist.sections.datalist[i].mesh.railpoint,
+          rail:data.mapdata.sectionlist.sections.datalist[i].rail,
+          position:data.mapdata.sectionlist.sections.datalist[i].mesh.position,
+          rotation:data.mapdata.sectionlist.sections.datalist[i].mesh.rotation,
+          scale:data.mapdata.sectionlist.sections.datalist[i].mesh.scale,
+        }
+        let nowmesh =  data.mapdata.sectionlist.sectiongroup.getObjectByProperty("code",section.code);
+        section.railpoint = nowmesh.railpoint;
+        // console.log(nowmesh.railpoint);
+        // if(data.mapdata.sectionlist.sections.datalist[i].rsection){
+        //   section.rsection = data.mapdata.sectionlist.sections.datalist[i].rsection;
+        // }
+        // if(data.mapdata.sectionlist.sections.datalist[i].lsection){
+        //   section.lsection = data.mapdata.sectionlist.sections.datalist[i].lsection;
+        // }
+        // if(data.mapdata.sectionlist.sections.datalist[i].csection){
+        //   section.csection = data.mapdata.sectionlist.sections.datalist[i].csection;
+        // }
+
+        // testmesh1.position.z = link.position.z;
+
+        sections.push(section);
+      }
+      let arrray = {
+          section:sections,
+      };
+      postmap.sections = JSON.stringify(arrray);
+      //道岔
+      let switchs = [];
+
+      for(let i=0;i<data.mapdata.switchlist.switchs.datalist.length;i++){
+        let switcha = {
+          // uuid:data.mapdata.switchlist.switchs.modellist[i].uuid,
+          code:data.mapdata.switchlist.switchs.datalist[i].code,
+          name:data.mapdata.switchlist.switchs.datalist[i].name,
+          pa:data.mapdata.switchlist.switchs.datalist[i].pa,
+          pb:data.mapdata.switchlist.switchs.datalist[i].pb,
+          pc:data.mapdata.switchlist.switchs.datalist[i].pc,
+          position:data.mapdata.switchlist.switchs.modellist[i].position,
+          rotation:data.mapdata.switchlist.switchs.modellist[i].rotation,
+          scale:data.mapdata.switchlist.switchs.modellist[i].scale
+        }
+        switchs.push(switcha);
+      }
+      postmap.switchs = JSON.stringify(switchs);
+      //信号
+      let signals = [];
+      for(let i=0;i<data.mapdata.signallist.list.length;i++){
+
+
+        let signal = {
+          // uuid:data.mapdata.signallist.list[i].mesh.uuid,
+          name:data.mapdata.signallist.list[i].mesh.name,
+          modelid:data.mapdata.signallist.list[i].mesh.modelid,
+          code:data.mapdata.signallist.list[i].mesh.code,
+          right:data.mapdata.signallist.list[i].mesh.right,
+          position:data.mapdata.signallist.list[i].mesh.position,
+          rotation:data.mapdata.signallist.list[i].mesh.rotation,
+          scale:data.mapdata.signallist.list[i].mesh.scale
+        }
+
+        signals.push(signal);
+      }
+      postmap.signals = JSON.stringify(signals);
+      //车站
+      let stands = [];
+
+      for(let i=0;i<data.mapdata.stationstandlist.list.length;i++){
+        console.log(data.mapdata.stationstandlist.list[i]);
+        let station = {
+          // uuid:data.mapdata.stationstandlist.list[i].uuid,
+          code:data.mapdata.stationstandlist.list[i].code,
+          name:data.mapdata.stationstandlist.list[i].name,
+          // modelid:data.mapdata.stationstandlist.list[i].modelid,
+          position:data.mapdata.stationstandlist.list[i].mesh.position,
+          rotation:data.mapdata.stationstandlist.list[i].mesh.rotation,
+          scale:data.mapdata.stationstandlist.list[i].mesh.scale,
+          inside:data.mapdata.stationstandlist.list[i].inside,
+          stands:data.mapdata.stationstandlist.list[i].stands,
+          // direction1:{
+          //   name:data.mapdata.stationstandlist.list[i].direction1.name,
+          //   code:data.mapdata.stationstandlist.list[i].direction1.code
+          // },
+          // direction2:{
+          //   name:data.mapdata.stationstandlist.list[i].direction2.name,
+          //   code:data.mapdata.stationstandlist.list[i].direction2.code
+          // }
+        }
+        console.log(station);
+        stands.push(station);
+      }
+        postmap.stands  = JSON.stringify(stands);
+      //列车
+      let trains = [];
+      for(let i=0;i<data.assetloader.modellist.length;i++){
+        if(data.assetloader.modellist[i].deviceType == "train"){
+          let train = {
+            id:data.assetloader.modellist[i].id,
+            name:data.assetloader.modellist[i].name,
+            deviceType:data.assetloader.modellist[i].deviceType,
+            type:data.assetloader.modellist[i].type,
+            assetUrl:data.assetloader.modellist[i].assetUrl
+          }
+
+          trains.push(train);
+        }
+      }
+      postmap.trains = JSON.stringify(trains);
+
+      return postmap;
+    }
+
+  }
diff --git a/src/jlmap3d/edit/jl3dEditorLoader.js b/src/jlmap3d/edit/jl3dEditorLoader.js
new file mode 100644
index 000000000..238b4c703
--- /dev/null
+++ b/src/jlmap3d/edit/jl3dEditorLoader.js
@@ -0,0 +1,188 @@
+import { getPublishMapDetail,getMapDetail,set3dMapData,get3dMapData } from '@/api/jlmap3d/load3ddata';
+
+//原始信息obj化提供给三维建模
+import {SetObj} from '@/jlmap3d/edit/utils/SetObj.js';
+//componnent
+import {SectionList} from '@/jlmap3d/edit/testEditorModel/SectionList.js';
+import {SignalList} from '@/jlmap3d/edit/testEditorModel/SignalList.js';
+import {StationStandList} from '@/jlmap3d/edit/testEditorModel/StationStandList.js';
+import {SwitchList} from '@/jlmap3d/edit/testEditorModel/SwitchList.js';
+import {RailList} from '@/jlmap3d/edit/testEditorModel/RailList.js';
+
+import axios from 'axios';
+import {getmodels} from '@/jlmap3d/edit/connect/getmodels';
+import { Loading } from 'element-ui';
+// import {SwitchModel} from '@/jlmap3d/model/SwitchModel.js';
+
+export function jl3dEditorLoader(mapid,scope){
+  let editmapid = mapid;
+  let scene = scope.scene;
+  let jlmap3ddata = scope.mapdata;
+  let jlmap3dasset = scope.assetManager;
+  let assetloader = scope.assetloader;
+  let loadingInstance = Loading.service({ fullscreen: true });
+  get3dMapData(editmapid).then(data => {
+
+    if(data.data ){
+      if(data.data.assets){
+
+        loadData(editmapid,data.data);
+      }else{
+        initData(editmapid,data.data.id);
+      }
+
+    }else{
+      let params = {mapId:editmapid};
+
+      set3dMapData(params).then(data => {
+        if(data.code == "200"){
+          //console.log("创建三维数据成功");
+          // console.log(data);
+          initData(editmapid,data.data.id);
+
+        }
+      }).catch(error => {
+        console.log(error);
+      });
+    }
+
+  }).catch(error => {
+    console.log(error);
+  });
+
+  function initData(mapid,data3did){
+
+    getMapDetail(mapid).then(data => {
+      console.log(data);
+      let mapdata = data.data;
+      //console.log(data3did);
+      jlmap3ddata.id = data3did;
+      jlmap3ddata.mapId = mapid;
+
+      // //初始化站台
+      jlmap3ddata.stationstandlist = new StationStandList();
+      //初始化轨道和道岔   暂时
+      jlmap3ddata.sectionlist = new SectionList();
+
+      jlmap3ddata.signallist = new SignalList();
+
+      jlmap3ddata.switchlist = new SwitchList();
+      //
+      jlmap3ddata.raillist = new RailList();
+      jlmap3ddata.raillist.setrail();
+
+      assetloader.assetinit(scene)
+      .then(function(data){
+        //console.log(data);
+        return  jlmap3ddata.stationstandlist.initpromise(jlmap3ddata,mapdata.stationList,mapdata.stationStandList,scene,assetloader);
+      })
+      .then(function(data){
+        //console.log(data);
+        return   jlmap3ddata.sectionlist.initpromise(jlmap3ddata,assetloader,mapdata.sectionList,mapdata.switchList,scene);
+      })
+      .then(function(data){
+        //console.log(data);
+        return   jlmap3ddata.signallist.initpromise(jlmap3ddata,mapdata.signalList,scene,assetloader);
+      })
+      .then(function(data){
+        return  jlmap3ddata.switchlist.initpromise(jlmap3ddata,mapdata.switchList,scene,assetloader);
+      })
+
+      .then(function(data){
+        //console.log(data);
+        loadingInstance.close();
+      });
+      //初始化信号
+      //SetObj(mapdata,scope);
+
+    });
+  }
+
+  function loadData(mapid,netdata){
+
+    // console.log(netdata)
+    getMapDetail(mapid).then(data => {
+      jlmap3ddata.id = netdata.id;
+      jlmap3ddata.mapId = mapid;
+      let mapdata = data.data;
+      // console.log(netdata);
+      // //初始化站台
+      jlmap3ddata.stationstandlist = new StationStandList();
+      //初始化轨道和道岔   暂时
+      jlmap3ddata.sectionlist = new SectionList();
+
+      jlmap3ddata.signallist = new SignalList();
+
+      jlmap3ddata.switchlist = new SwitchList();
+
+      jlmap3ddata.raillist = new RailList();
+
+      let sectiondata = JSON.parse(netdata.sections);
+      let switchdata = JSON.parse(netdata.switchs);
+      let signaldata = JSON.parse(netdata.signals);
+      let standsdata = JSON.parse(netdata.stands);
+      jlmap3dasset = JSON.parse(netdata.assets);
+      console.log(netdata);
+      if(jlmap3dasset.sceneAssetList == undefined){
+
+        // loadEditAllAsset(jlmap3dasset);
+        assetloader.setmodellistnew(netdata.assets,5);
+        assetloader.assetpromise(scene)
+        .then(function(data){
+          // return  jlmap3ddata.stationstandlist.initpromise(jlmap3ddata,mapdata.stationList,mapdata.stationStandList,scene,assetloader);
+          return jlmap3ddata.stationstandlist.loadpromise(jlmap3ddata,standsdata,mapdata.stationStandList,scene,assetloader);
+        })
+        .then(function(data){
+          //console.log(data);
+          // return jlmap3ddata.sectionlist.initpromise(jlmap3ddata,assetloader,mapdata.sectionList,mapdata.switchList,scene);
+          return jlmap3ddata.sectionlist.loadpromise(jlmap3ddata,assetloader,sectiondata.section,scene);
+        })
+        .then(function(data){
+          //console.log(data);
+          // return   jlmap3ddata.signallist.initpromise(jlmap3ddata,mapdata.signalList,scene,assetloader);
+          return jlmap3ddata.signallist.loadpromise(signaldata,scene,assetloader,mapdata.signalList);
+        })
+        .then(function(data){
+          // return  jlmap3ddata.switchlist.initpromise(jlmap3ddata,mapdata.switchList,scene,assetloader);
+          return jlmap3ddata.switchlist.loadpromise(jlmap3ddata,switchdata,scene,assetloader);
+        })
+        .then(function(data){
+          //console.log(data);
+          loadingInstance.close();
+        });
+      }else{
+        loadEditAllAsset(jlmap3dasset);
+        assetloader.setModelListOver(jlmap3dasset.sceneAssetList,5);
+        assetloader.assetPromiseOver(scene)
+        .then(function(data){
+          console.log(assetloader.modellist);
+          // return  jlmap3ddata.stationstandlist.initpromise(jlmap3ddata,mapdata.stationList,mapdata.stationStandList,scene,assetloader);
+          return jlmap3ddata.stationstandlist.loadpromise(jlmap3ddata,standsdata,mapdata.stationStandList,scene,assetloader);
+        })
+        .then(function(data){
+          //console.log(data);
+          // return jlmap3ddata.sectionlist.initpromise(jlmap3ddata,assetloader,mapdata.sectionList,mapdata.switchList,scene);
+          return jlmap3ddata.sectionlist.loadpromise(jlmap3ddata,assetloader,sectiondata.section,scene);
+        })
+        .then(function(data){
+          //console.log(data);
+          // return   jlmap3ddata.signallist.initpromise(jlmap3ddata,mapdata.signalList,scene,assetloader);
+          return jlmap3ddata.signallist.loadpromise(signaldata,scene,assetloader,mapdata.signalList);
+        })
+        .then(function(data){
+          // return  jlmap3ddata.switchlist.initpromise(jlmap3ddata,mapdata.switchList,scene,assetloader);
+          return jlmap3ddata.switchlist.loadpromise(jlmap3ddata,switchdata,scene,assetloader);
+        })
+        .then(function(data){
+          //console.log(data);
+          loadingInstance.close();
+        });
+      }
+
+
+    });
+  }
+
+
+
+}
diff --git a/src/jlmap3d/edit/jlmap3dedit.js b/src/jlmap3d/edit/jlmap3dedit.js
index d2bc5caff..d3aebbe86 100644
--- a/src/jlmap3d/edit/jlmap3dedit.js
+++ b/src/jlmap3d/edit/jlmap3dedit.js
@@ -23,8 +23,8 @@ import { SetScene } from '@/jlmap3d/config/SetScene';
 import { SetLights } from '@/jlmap3d/config/SetLights';
 
 //加载器
-// import { Jlmap3ddata } from '@/jlmap3d/edit/Jlmap3ddata';
-import { Jlmap3ddata } from '@/jlmap3d/edit/Jlmap3dnewdata';
+// import { jl3dEditorLoader } from '@/jlmap3d/edit/jl3dEditorLoader';
+import { jl3dEditorLoader } from '@/jlmap3d/edit/jl3dEditorLoader';
 //操作管理器
 import { Actionmanage } from '@/jlmap3d/edit/actionmanage';
 
@@ -96,7 +96,7 @@ export function JLmap3dEdit(dom, data, mapid) {
     path:[]
   };
   this.assetManager = null;
-  Jlmap3ddata(mapid,scope);
+  jl3dEditorLoader(mapid,scope);
 
   let scalControls = new THREE.ScalControls(scope.scene,scope.camera, scope.renderer.domElement );
   this.scalswitch = false;
diff --git a/src/jlmap3d/edit/neweditmodel/StationStandList.js b/src/jlmap3d/edit/neweditmodel/StationStandList.js
index 674172001..574ee7954 100644
--- a/src/jlmap3d/edit/neweditmodel/StationStandList.js
+++ b/src/jlmap3d/edit/neweditmodel/StationStandList.js
@@ -28,7 +28,7 @@ export function StationStandList() {
 
         let newstationstand = new StationStandModel(stationdata[i]);
         //判断站台是否显示
-        console.log(stationdata[i]);
+      
         if(stationdata[i].visible == true){
 
           //遍历车站站台数据
diff --git a/src/jlmap3d/edit/testEditorModel/RailList.js b/src/jlmap3d/edit/testEditorModel/RailList.js
new file mode 100644
index 000000000..28cbe68e1
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/RailList.js
@@ -0,0 +1,84 @@
+export function RailList(){
+  let scope = this;
+
+  this.linkrail = [];
+
+  this.switchrail = [];
+
+  this.setrail = function(){
+
+  };
+
+
+  this.resetrail = function(mapdata,scene){
+
+
+    let section = mapdata.sectionlist.sections.datalist;
+
+    let n =0;
+    for(let i in section){
+
+      n = n+1;
+      var geometry = new THREE.PlaneBufferGeometry( section[i].lengthFact, 1, 1 );
+      var material = new THREE.MeshBasicMaterial( {color: 0xffff00, side: THREE.DoubleSide} );
+      var plane = new THREE.Mesh( geometry, material );
+      plane.position.x = section[i].mesh.position.x;
+      plane.position.y = 2+Math.random()*10;
+      plane.position.z = section[i].mesh.position.z;
+      plane.rotation.x = -Math.PI/2;
+      plane.rotation.z = section[i].mesh.rotation._z;
+
+      // if(  plane.rotation.z != ){
+      //
+      // }
+      var geometry1 = new THREE.CircleBufferGeometry( 1, 16 );
+      var material1 = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
+      var geometry2 = new THREE.CircleBufferGeometry( 1, 16 );
+      var material2 = new THREE.MeshBasicMaterial( { color: 0xff2000 } );
+      var circle1 = new THREE.Mesh( geometry1, material1 );
+
+      circle1.rotation.x = -Math.PI/2;
+
+
+      var circle2 = new THREE.Mesh( geometry2, material2 );
+
+      circle2.rotation.x = -Math.PI/2;
+
+      circle1.position.x = plane.position.x + (section[i].lengthFact)/2*Math.cos(plane.rotation.z);
+      circle1.position.y = 1;
+      circle1.position.z = plane.position.z - (section[i].lengthFact)/2*Math.sin(plane.rotation.z);
+      circle2.position.x = plane.position.x - (section[i].lengthFact)/2*Math.cos(plane.rotation.z);
+      circle2.position.y = 0.5;
+      circle2.position.z = plane.position.z + (section[i].lengthFact)/2*Math.sin(plane.rotation.z);
+        // }
+      scene.add( circle1 );
+      scene.add( circle2 );
+      scene.add( plane );
+      mapdata.sectionlist.sections.datalist[i].rail = [{
+        x:circle2.position.x,
+        z:circle2.position.z
+      },{
+        x:circle1.position.x,
+        z:circle1.position.z
+      }];
+      // console.log(i);
+      // console.log(section[i].mesh);
+      // console.log(mapdata.sectionlist.sections.datalist[i].rail);
+      // console.log("=======================");
+    }
+    // console.log(n);
+    // for(let i=0;i<mapdata.switchlist.switchgroup.children.length;i++){
+    //   var geometry = new THREE.CircleBufferGeometry( 1, 16 );
+    //   var material = new THREE.MeshBasicMaterial( { color: 0xff00ff } );
+    //   var circle1 = new THREE.Mesh( geometry, material );
+    //   circle1.position.x = mapdata.switchlist.switchgroup.children[i].position.x;
+		// 	circle1.position.z = mapdata.switchlist.switchgroup.children[i].position.z;
+		// 	circle1.rotation.x = -Math.PI/2;
+    //   scene.add( circle1 );
+    // }
+  };
+
+  this.getrail = function(){
+
+  };
+}
diff --git a/src/jlmap3d/edit/testEditorModel/SectionList.js b/src/jlmap3d/edit/testEditorModel/SectionList.js
new file mode 100644
index 000000000..e41fcb48c
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/SectionList.js
@@ -0,0 +1,1005 @@
+import {SectionModel} from '@/jlmap3d/edit/editmodel/SectionModel.js';
+import {SwitchModel} from '@/jlmap3d/edit/editmodel/SwitchModel.js';
+export function SectionList() {
+
+  let scope = this;
+  this.type = "sectionlist";
+  this.sectiongroup = new THREE.Group();
+  this.sectiongroup.name = "section";
+  this.sections = {
+    datalist:[],
+    modellist:[]
+  };
+  this.stopsection = [];
+  this.standtrack = [];
+  var autorail;
+
+  var color = new THREE.Color(0xFF0000);
+  var colorArray = new Float32Array([Math.random(),Math.random(),Math.random()]);
+
+
+
+  this.initpromise = function(jlmap3ddata,assetloader,sectiondata,switchdata,scene){
+    var texture = new THREE.TextureLoader().load( '../../static/test/z0251.png' );
+        texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+        texture.repeat.set( 1,1);
+
+    var selectmaterial = new THREE.MeshPhongMaterial( { map: texture,transparent:true,alphaTest:0.1 } );
+
+
+    scene.add(scope.sectiongroup);
+    return new Promise(function(resolve, reject){
+      //收集需要显示区段
+      for(let i=0;i<sectiondata.length;i++){
+        if(sectiondata[i].type == "01" || sectiondata[i].type == "03"){
+          //初始化区段对象数据
+          let newsection = new SectionModel(sectiondata[i]);
+          // console.log(sectiondata[i]);
+          newsection.name = sectiondata[i].name;
+          newsection.code = sectiondata[i].code;
+          newsection.index = i;
+          newsection.type = sectiondata[i].type;
+          newsection.lengthFact = sectiondata[i].lengthFact;
+
+          newsection.stationcode = sectiondata[i].stationCode;
+          newsection.rsection = sectiondata[i].rightSectionCode;
+          newsection.lsection = sectiondata[i].leftSectionCode;
+          newsection.points = sectiondata[i].points;
+          newsection.pointslength = sectiondata[i].points.length-1;
+          newsection.railpoint = [];
+          // console.log(sectiondata[i].points.length);
+          newsection.standTrack = sectiondata[i].standTrack;
+
+          newsection.endbuild = false;
+          newsection.rp = {
+            x:0,
+            y:0,
+            z:0
+          };
+          newsection.lp = {
+            x:0,
+            y:0,
+            z:0
+          };
+          scope.sections.datalist[sectiondata[i].code] = newsection;
+
+
+          if(sectiondata[i].standTrack == true){
+
+            sectiondata[i].endCount = false;
+            sectiondata[i].standLeftX = sectiondata[i].points[0].x;
+            sectiondata[i].standLeftY = sectiondata[i].points[0].y;
+            sectiondata[i].standRightLeftX = sectiondata[i].points[1].x;
+            sectiondata[i].standRightRightY = sectiondata[i].points[1].y;
+            scope.sections.datalist[sectiondata[i].code].leftStopPointOffset = sectiondata[i].leftStopPointOffset;
+            scope.sections.datalist[sectiondata[i].code].rightStopPointOffset = sectiondata[i].leftStopPointOffset+124;
+
+            // if(sectiondata[i].lengthFact<70){
+            //   scope.sections.datalist[sectiondata[i].code].lengthFact = 63;
+            // }else if(sectiondata[i].lengthFact<140){
+            //   scope.sections.datalist[sectiondata[i].code].lengthFact = 134;
+            // }else{
+            //
+            // }
+            scope.sections.datalist[sectiondata[i].code].lengthFact = sectiondata[i].lengthFact;
+
+            // sectiondata[i].lengthFact = 134;
+            scope.stopsection.push(sectiondata[i]);
+          }
+          // sections.modellist.push("");
+        }
+      }
+
+      //连接区段
+      for(let i=0;i<switchdata.length;i++){
+        let acode = switchdata[i].sectionACode;
+        let bcode = switchdata[i].sectionBCode;
+        let ccode = switchdata[i].sectionCCode;
+        // console.log(switchdata[i]);
+
+
+        let aposx = (scope.sections.datalist[acode].points[0].x + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].x)/2;
+        let cposx = (scope.sections.datalist[ccode].points[0].x + scope.sections.datalist[ccode].points[scope.sections.datalist[ccode].pointslength].x)/2;
+
+        let aposy = (scope.sections.datalist[acode].points[0].y + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].y)/2;
+        let cposy = (scope.sections.datalist[ccode].points[0].y + scope.sections.datalist[ccode].points[scope.sections.datalist[ccode].pointslength].y)/2;
+
+        // console.log("----------------");
+        if(aposx > cposx){
+          if(aposy < cposy){
+            //  ——A
+            //  /C
+            scope.sections.datalist[ccode].ctype = 1;
+          }else{
+            //   \C
+            //   ——A
+            scope.sections.datalist[ccode].ctype = 2;
+          }
+        }else{
+          if(aposy < cposy){
+            //  A——
+            //    \C
+            scope.sections.datalist[ccode].ctype = 3;
+          }else{
+            //    /C
+            //  A——
+            scope.sections.datalist[ccode].ctype = 4;
+          }
+        }
+
+        scope.sections.datalist[acode].csection = ccode;
+
+        if(scope.sections.datalist[ccode].ctype == 1 || scope.sections.datalist[ccode].ctype == 2){
+          if(scope.sections.datalist[acode].lsection == "" || scope.sections.datalist[acode].lsection == undefined){
+            scope.sections.datalist[acode].lsection = bcode;
+          }
+
+          if(scope.sections.datalist[bcode].rsection == "" || scope.sections.datalist[bcode].rsection == undefined){
+            scope.sections.datalist[bcode].rsection = acode;
+          }
+
+          if(scope.sections.datalist[ccode].rsection == "" || scope.sections.datalist[ccode].rsection == undefined){
+            scope.sections.datalist[ccode].rsection = acode;
+          }else if(scope.sections.datalist[ccode].lsection == "" || scope.sections.datalist[ccode].lsection == undefined){
+            scope.sections.datalist[ccode].lsection = acode;
+          }
+        }
+
+        if(scope.sections.datalist[ccode].ctype == 3 || scope.sections.datalist[ccode].ctype == 4){
+          if(scope.sections.datalist[acode].rsection == "" || scope.sections.datalist[acode].rsection == undefined){
+            scope.sections.datalist[acode].rsection = bcode;
+          }
+
+          if(scope.sections.datalist[bcode].lsection == "" ||scope.sections.datalist[bcode].lsection == undefined ){
+            scope.sections.datalist[bcode].lsection = acode;
+          }
+
+          if(scope.sections.datalist[ccode].rsection == "" || scope.sections.datalist[ccode].rsection == undefined){
+            scope.sections.datalist[ccode].rsection = acode;
+          }else if(scope.sections.datalist[ccode].lsection == "" || scope.sections.datalist[ccode].lsection == undefined){
+            scope.sections.datalist[ccode].lsection = acode;
+          }
+        }
+
+
+      }
+
+      let stationlist = jlmap3ddata.stationstandlist.list;
+      let stopsections = [];
+
+      for(let i=0,leni = stationlist.length;i<leni;i++){
+
+        let realstopsection ={
+          reals:[],
+          posx:null,
+        };
+        // console.log(stationlist[i]);
+
+        // realstopsection.stands.push();
+        for(let j=0,lenj = scope.stopsection.length;j<lenj;j++){
+
+          for(let n=0,lenn = stationlist[i].stands.length;n<lenn;n++){
+            if(scope.stopsection[j].code == stationlist[i].stands[n].section){
+              let stopsection = {
+                section:scope.stopsection[j],
+                code:stationlist[i].stands[n].section,
+              };
+
+              if(realstopsection.reals.length == 0){
+                realstopsection.reals.push(stopsection);
+              }else{
+                let isHave = false;
+                for(let m=0,lenm = realstopsection.reals.length;m<lenm;m++){
+                  if(realstopsection.reals[m].code == stopsection.code){
+                    isHave = true;
+                  }
+                }
+                if(isHave == false){
+                  realstopsection.reals.push(stopsection);
+                }
+              }
+
+
+            }
+          }
+
+        }
+
+        realstopsection.posx = realstopsection.reals[0].section.points[0].x;
+
+        stopsections.push(realstopsection);
+      }
+
+
+      console.log(stopsections);
+
+      stopsections.sort(compare("posx"))
+
+
+
+      let leng1 = 0;
+      let leng2 = 0;
+
+      for(let i=0,leni=stopsections.length;i<leni;i++){
+        if(stopsections[i+1]){
+          let findarray = [];
+
+          for(let j=0,lenj=stopsections[i].reals.length;j<lenj;j++){
+
+            let finder = {
+              startSection:stopsections[i].reals[j].section,
+              endSection:null,
+              distance:0,
+              sectionArrays:[],
+            };
+            let findResults = findnextsection(finder,scope.sections.datalist[stopsections[i].reals[j].code].rsection);
+
+
+            if(findResults){
+              if(findarray.hasOwnProperty(finder.endSection.stationcode)){
+                findarray[finder.endSection.stationcode].push(finder);
+              }else{
+                findarray[finder.endSection.stationcode] = [];
+                findarray[finder.endSection.stationcode].push(finder);
+              }
+
+            }
+          }
+          for(let k in findarray){
+            // findarray[k]
+            if(findarray[k].length>0){
+              let nowFindArray = findarray[k];
+              let maxlengthfact = 0;
+              let maxsection = null;
+
+              let topNowSection = scope.sections.datalist[nowFindArray[0].startSection.code];
+              let topNextSection = scope.sections.datalist[nowFindArray[0].endSection.code];
+              let downNowSection = scope.sections.datalist[nowFindArray[1].startSection.code];
+              let downNextSection = scope.sections.datalist[nowFindArray[1].endSection.code];
+
+              let topStopPointLength = nowFindArray[0].distance+(topNowSection.lengthFact-topNowSection.rightStopPointOffset)+topNextSection.leftStopPointOffset;
+              let downStopPointLength = nowFindArray[1].distance+(downNowSection.lengthFact-downNowSection.rightStopPointOffset)+downNextSection.leftStopPointOffset;
+              if(topStopPointLength > downStopPointLength){
+                if(nowFindArray[0].sectionArrays.length == 0 && nowFindArray[1].sectionArrays.length == 0){
+
+                }else if(nowFindArray[1].sectionArrays.length > 0){
+                  let offset = topStopPointLength - downStopPointLength;
+                  for(let n=0,lenn= nowFindArray[1].sectionArrays.length;n<lenn;n++){
+                    if(nowFindArray[1].sectionArrays[n].lengthFact>maxsection){
+                      maxlengthfact = nowFindArray[1].sectionArrays[n].lengthFact;
+                      maxsection = nowFindArray[1].sectionArrays[n];
+                    }
+                  }
+                  scope.sections.datalist[maxsection.code].lengthFact += offset;
+                }else{
+                  let offset = topStopPointLength - downStopPointLength;
+                  for(let n=0,lenn= nowFindArray[0].sectionArrays.length;n<lenn;n++){
+                    if(nowFindArray[0].sectionArrays[n].lengthFact>maxsection){
+                      maxlengthfact = nowFindArray[0].sectionArrays[n].lengthFact;
+                      maxsection = nowFindArray[0].sectionArrays[n];
+                    }
+                  }
+                  scope.sections.datalist[maxsection.code].lengthFact -= offset;
+                }
+
+              }else if(topStopPointLength < downStopPointLength){
+
+                if(nowFindArray[0].sectionArrays.length == 0 && nowFindArray[1].sectionArrays.length == 0){
+
+                }else if(nowFindArray[0].sectionArrays.length > 0){
+                  let offset = downStopPointLength - topStopPointLength;
+                  for(let n=0,lenn= nowFindArray[0].sectionArrays.length;n<lenn;n++){
+                    if(nowFindArray[0].sectionArrays[n].lengthFact>maxsection){
+                      maxlengthfact = nowFindArray[0].sectionArrays[n].lengthFact;
+                      maxsection = nowFindArray[0].sectionArrays[n];
+                    }
+                  }
+                  scope.sections.datalist[maxsection.code].lengthFact += offset;
+                }else{
+                  let offset = downStopPointLength - topStopPointLength;
+                  for(let n=0,lenn= nowFindArray[1].sectionArrays.length;n<lenn;n++){
+                    if(nowFindArray[1].sectionArrays[n].lengthFact>maxsection){
+                      maxlengthfact = nowFindArray[1].sectionArrays[n].lengthFact;
+                      maxsection = nowFindArray[1].sectionArrays[n];
+                    }
+                  }
+                  scope.sections.datalist[maxsection.code].lengthFact -= offset;
+                }
+              }
+            }
+          }
+        }
+      }
+
+      let topstartpoint = {
+        x:0,
+        y:0,
+        z:0
+      };
+
+      let downstartpoint = {
+        x:0,
+        y:0,
+        z:0
+      };
+
+      createsection(stopsections[0].reals[0].code,topstartpoint,stopsections[0].reals[0].code,0);
+      createsection(stopsections[0].reals[1].code,downstartpoint,stopsections[0].reals[1].code,34.8);
+
+      for(let i=1,leni=stopsections.length;i<leni;i++){
+        console.log(stopsections[i]);
+        if(stopsections[i+1] ){
+          for(let j=0,lenj=stopsections[i].reals.length;j<lenj;j++){
+            console.log("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
+
+            console.log(stopsections[i].reals[j]);
+            console.log(scope.sections.datalist);
+            console.log(scope.sections.datalist[stopsections[i].reals[j].section.rightSectionCode]);
+            let topnextpoint = {};
+
+            if(scope.sections.datalist[stopsections[i].reals[j].section.code].railpoint == 0){
+              topnextpoint = {
+                x:scope.sections.datalist[stopsections[i].reals[0].section.code].railpoint[0].x,
+                y:0,
+                z:34.8*j
+              };
+            }else{
+              topnextpoint = {
+                x:scope.sections.datalist[stopsections[i].reals[j].section.code].railpoint[0].x,
+                y:0,
+                z:scope.sections.datalist[stopsections[i].reals[j].section.code].railpoint[2].z
+              };
+            }
+
+            createsection(stopsections[i].reals[j].code,topnextpoint,stopsections[i].reals[j].code,34.8*j);
+          }
+
+          //
+          // let topnextpoint = {
+          //   x:scope.sections.datalist[stopsections[i].reals[0].section.leftSectionCode].railpoint[2].x,
+          //   y:0,
+          //   z:scope.sections.datalist[stopsections[i].reals[0].section.leftSectionCode].railpoint[2].z
+          // };
+          //
+          // let downnextpoint = {
+          //   x:scope.sections.datalist[stopsections[i].reals[1].section.leftSectionCode].railpoint[2].x,
+          //   y:0,
+          //   z:scope.sections.datalist[stopsections[i].reals[1].section.leftSectionCode].railpoint[2].z
+          // };
+          //
+          //
+          // createsection(stopsections[i].reals[0],topnextpoint,stopsections[i].reals[0].code,0);
+          // createsection(stopsections[i].reals[1],downnextpoint,stopsections[i].reals[1].code,34.8);
+
+
+        }
+      }
+
+      let stations = jlmap3ddata.stationstandlist.list;
+      let num;
+      let num2;
+      for(let j=0;j<assetloader.modellist.length;j++){
+        if(assetloader.modellist[j].deviceType == "stand"){
+          num = j;
+        }
+        if(assetloader.modellist[j].deviceType == "standwaice"){
+          num2 = j;
+          assetloader.modellist[num2].mesh.rotation.x = 0;
+        }
+      }
+
+      for(let j=0,lenj=stations.length;j<lenj;j++){
+        // console.log(j);
+        console.log(stations[j]);
+        let direction1 = scope.sections.datalist[stations[j].stands[0].section];
+        let direction2 = scope.sections.datalist[stations[j].stands[1].section];
+        console.log(direction1);
+        let x = direction1.railpoint[0].x+direction1.leftStopPointOffset+62;
+        let z = (direction1.railpoint[0].z+direction2.railpoint[0].z)/2;
+        let mesh;
+        if(stations[j].stands[0].inside == true){
+          mesh = assetloader.modellist[num].mesh.clone(true);
+        }else{
+          mesh = assetloader.modellist[num2].mesh.clone(true);
+        }
+        jlmap3ddata.stationstandlist.list[j].modelid = assetloader.modellist[num].modelid;
+        jlmap3ddata.stationstandlist.list[j].mesh = mesh;
+
+        mesh.position.set(x,0,z);
+        scene.add( mesh );
+      }
+
+      // scope.sections.datalist[stations[0].stands[0].section].endbuild = true;
+      console.log("START BUILD !!!!!!!!!!!!!!!!!");
+      buildsectionall(scope.sections.datalist[stations[0].stands[0].section]);
+      resolve("loadersection");
+    });
+  };
+
+  function createsection(origin,position,start,py){
+    var texture = new THREE.TextureLoader().load( '../../static/test/z0251.png' );
+        texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+        texture.repeat.set( 1,1);
+
+    var selectmaterial = new THREE.MeshPhongMaterial( { map: texture,transparent:true,alphaTest:0.1 } );
+
+    position.z = py;
+    let len = scope.sections.datalist[start].lengthFact;
+    let height = Math.random()/1000;
+    scope.sections.datalist[start].railpoint = [
+      new THREE.Vector3(position.x,height,position.z),
+      new THREE.Vector3(position.x+0.5,height,position.z+0.0001),
+      new THREE.Vector3(position.x+len,height,position.z),
+    ];
+
+    let closedSpline = new THREE.CatmullRomCurve3( [
+      new THREE.Vector3(position.x,height,position.z),
+      new THREE.Vector3(position.x+0.5,height,position.z+0.0001),
+      new THREE.Vector3(position.x+len,height,position.z),
+    ] );
+    closedSpline.type = 'catmullrom';
+    closedSpline.closed = false;
+    var extrudeSettings = {
+        steps           : 5,
+        curveSegments   : 1,
+        bevelSegments   : 1,
+        bevelEnabled    : false,
+        extrudePath     : closedSpline,
+    };
+    var shape = new THREE.Shape();
+    shape.moveTo( 0,-2 );
+    shape.lineTo( 0, 2 );
+    var geometry = new THREE.ExtrudeBufferGeometry( shape, extrudeSettings );
+
+
+    var randomMaterail = new THREE.MeshLambertMaterial({
+        //color:color.fromArray(colorArray)
+        color:0xFFFFFF*Math.random()
+    })
+    let testmesh2;
+    if(scope.sections.datalist[start].standTrack == false){
+      testmesh2 = new THREE.Mesh( geometry, randomMaterail );
+    }else{
+      testmesh2 = new THREE.Mesh( geometry, selectmaterial );
+    }
+
+    // closedSpline.arcLengthDivisions;
+    let count = testmesh2.geometry.attributes.position.count/3;
+
+    for(let i=0;i<count;i++){
+      let ui=i*6;
+      if(i%2 != 0){
+        testmesh2.geometry.attributes.uv.array[ui] = 0;
+        testmesh2.geometry.attributes.uv.array[ui+1] = 1;
+        testmesh2.geometry.attributes.uv.array[ui+2] = len/5;
+        testmesh2.geometry.attributes.uv.array[ui+3] = 1;
+        testmesh2.geometry.attributes.uv.array[ui+4] = len/5;
+        testmesh2.geometry.attributes.uv.array[ui+5] = 0;
+      }else{
+        testmesh2.geometry.attributes.uv.array[ui] = 0;
+        testmesh2.geometry.attributes.uv.array[ui+1] = 0;
+        testmesh2.geometry.attributes.uv.array[ui+2] = 0;
+        testmesh2.geometry.attributes.uv.array[ui+3] = 1;
+        testmesh2.geometry.attributes.uv.array[ui+4] = len/5;
+        testmesh2.geometry.attributes.uv.array[ui+5] = 0;
+      }
+    }
+
+
+    testmesh2.code = start;
+    testmesh2.railpoint = scope.sections.datalist[start].railpoint;
+    testmesh2.lengthFact = scope.sections.datalist[start].railpoint.lengthFact;
+    scope.sections.datalist[start].mesh = testmesh2;
+    scope.sectiongroup.add( testmesh2 );
+
+    let topstartpoint = {
+      x:position.x+scope.sections.datalist[start].lengthFact,
+      y:0,
+      z:position.z
+    };
+    console.log(origin+"******************************");
+    console.log(start);
+    console.log(origin);
+    if(scope.sections.datalist[start].standTrack == true && start != origin){
+      console.log(start+"到达");
+      console.log("++++++++++++++++++++++++");
+      return ;
+    }else if(scope.sections.datalist[start].rsection == undefined){
+      return ;
+    }else{
+      return createsection(origin,topstartpoint,scope.sections.datalist[start].rsection,py);
+    }
+  }
+
+  function findnextsection(findarray,start){
+
+    if(start == undefined){
+      return findarray;
+    }
+    if(scope.sections.datalist[start].rsection == undefined){
+      return null;
+    }
+
+    if(scope.sections.datalist[start].standTrack == true){
+
+      findarray.endSection = scope.sections.datalist[start];
+      return findarray;
+    }else{
+      findarray.sectionArrays.push(scope.sections.datalist[start]);
+      findarray.distance = findarray.distance + scope.sections.datalist[start].lengthFact;
+      return  findnextsection(findarray,scope.sections.datalist[start].rsection);
+      // }
+    }
+  }
+  function compare(property){
+    return function(a,b){
+      var value1 = a[property];
+      var value2 = b[property];
+      return value1 - value2;
+    }
+  }
+  function buildsectionall(origin){
+    if(origin.rsection){
+      if(scope.sections.datalist[origin.rsection].endbuild == false){
+        scope.sections.datalist[origin.rsection].endbuild = true;
+        if(scope.sections.datalist[origin.rsection].mesh == null){
+          buildsection(origin,scope.sections.datalist[origin.rsection],"right");
+          buildsectionall(scope.sections.datalist[origin.rsection]);
+        }else{
+          buildsectionall(scope.sections.datalist[origin.rsection]);
+        }
+      }
+
+    }
+    if(origin.lsection){
+      if(scope.sections.datalist[origin.lsection].endbuild == false){
+        scope.sections.datalist[origin.lsection].endbuild = true;
+        if(scope.sections.datalist[origin.lsection].mesh == null){
+          buildsection(origin,scope.sections.datalist[origin.lsection],"left");
+          buildsectionall(scope.sections.datalist[origin.lsection]);
+        }else{
+          buildsectionall(scope.sections.datalist[origin.lsection]);
+        }
+      }
+    }
+    if(origin.csection){
+      if(scope.sections.datalist[origin.csection].endbuild == false){
+        scope.sections.datalist[origin.csection].endbuild = true;
+        if(scope.sections.datalist[origin.csection].mesh == null){
+          buildsection(origin,scope.sections.datalist[origin.csection],"cross");
+          buildsectionall(scope.sections.datalist[origin.csection]);
+        }else{
+          buildsectionall(scope.sections.datalist[origin.csection]);
+        }
+      }
+    }
+    // return ;
+  }
+
+  function buildsection(origin,data,type){
+
+    let len = data.lengthFact;
+    let height = Math.random()/1000;
+    var closedSpline;
+    let initRotation;
+
+    if(data.points[0].x == data.points[data.pointslength].x && data.points[0].y == data.points[data.pointslength].y){
+
+    }else{
+
+      if(type == "right"){
+        let dx = Math.abs(data.points[0].x - data.points[data.pointslength].x);
+        let dy = Math.abs(data.points[0].y - data.points[data.pointslength].y);
+        let distance = Math.sqrt(Math.pow(dx,2)+Math.pow(dy,2));
+
+        data.rp.x = (data.points[data.pointslength].x-data.points[0].x)*data.lengthFact/distance+origin.railpoint[2].x;
+        data.rp.z = (data.points[data.pointslength].y-data.points[0].y)*data.lengthFact/distance+origin.railpoint[2].z;
+
+        data.lp.x = origin.railpoint[2].x;
+        data.lp.z = origin.railpoint[2].z;
+        let axix = new THREE.Vector3(1,0,0);
+        let axixnow = new THREE.Vector3(data.rp.x-data.lp.x,0,data.rp.z-data.lp.z);
+        let rotenum = axixnow.angleTo(axix);
+        //不同坐标系方向值不同
+        if(data.points[0].y>data.points[data.pointslength].y){
+          initRotation = 0.2678;
+          data.rp.x = data.lp.x+(data.lengthFact)*Math.cos(initRotation);
+          data.rp.z = data.lp.z-(data.lengthFact)*Math.sin(initRotation);
+
+        }else if(data.points[0].y<data.points[data.pointslength].y){
+          initRotation = -0.2678;
+          data.rp.x = data.lp.x+(data.lengthFact)*Math.cos(initRotation);
+          data.rp.z = data.lp.z-(data.lengthFact)*Math.sin(initRotation);
+
+        }else{
+          data.rp.z = data.lp.z;
+
+        }
+
+
+
+        closedSpline = new THREE.CatmullRomCurve3( [
+          new THREE.Vector3(data.lp.x,0,data.lp.z),
+          new THREE.Vector3((data.lp.x+data.rp.x)/2,0,(data.lp.z+data.rp.z)/2-0.001),
+          new THREE.Vector3(data.rp.x,0,data.rp.z),
+        ] );
+        data.railpoint = [
+          new THREE.Vector3(data.lp.x,0,data.lp.z),
+          new THREE.Vector3((data.lp.x+data.rp.x)/2,0,(data.lp.z+data.rp.z)/2-0.001),
+          new THREE.Vector3(data.rp.x,0,data.rp.z),
+        ];
+
+
+      }
+      if(type == "left"){
+        let dx = Math.abs(data.points[0].x - data.points[data.pointslength].x);
+        let dy = Math.abs(data.points[0].y - data.points[data.pointslength].y);
+        let distance = Math.sqrt(Math.pow(dx,2)+Math.pow(dy,2));
+
+        data.lp.x = (data.points[0].x-data.points[data.pointslength].x)*data.lengthFact/distance+origin.railpoint[0].x;
+        data.lp.z = (data.points[0].y-data.points[data.pointslength].y)*data.lengthFact/distance+origin.railpoint[0].z;
+
+        data.rp.x = origin.railpoint[0].x;
+        data.rp.z = origin.railpoint[0].z;
+
+
+        let axix = new THREE.Vector3(1,0,0);
+        let axixnow = new THREE.Vector3(data.rp.x-data.lp.x,0,data.rp.z-data.lp.z);
+
+        let rotenum = axixnow.angleTo(axix);
+        //不同坐标系方向值不同
+        if(data.points[0].y>data.points[data.pointslength].y){
+          initRotation = 0.2678;
+          data.lp.x = data.rp.x - (data.lengthFact)*Math.cos(initRotation);
+          data.lp.z = data.rp.z + (data.lengthFact)*Math.sin(initRotation);
+        }else if(data.points[0].y<data.points[data.pointslength].y){
+          initRotation = -0.2678;
+          data.lp.x = data.rp.x - (data.lengthFact)*Math.cos(initRotation);
+          data.lp.z = data.rp.z + (data.lengthFact)*Math.sin(initRotation);
+        }else{
+          data.lp.z = data.rp.z;
+        }
+        closedSpline = new THREE.CatmullRomCurve3( [
+          new THREE.Vector3(data.lp.x,0,data.lp.z),
+          new THREE.Vector3((data.lp.x+data.rp.x)/2,0,(data.lp.z+data.rp.z)/2-0.001),
+          new THREE.Vector3(data.rp.x,0,data.rp.z),
+        ] );
+        data.railpoint = [
+          new THREE.Vector3(data.lp.x,0,data.lp.z),
+          new THREE.Vector3((data.lp.x+data.rp.x)/2,0,(data.lp.z+data.rp.z)/2-0.001),
+          new THREE.Vector3(data.rp.x,0,data.rp.z),
+        ];
+      }
+
+      // console.log(data.ctype);
+      if(type == "cross"){
+        // console.log(data.ctype);
+        // console.log(scope.sections.datalist[data.code].points.length);
+        // console.log(scope.sections.datalist[data.code]);
+        if(data.ctype == "1"||data.ctype == "2" ){
+
+
+          let dx = Math.abs(data.points[0].x - data.points[data.pointslength].x);
+          let dy = Math.abs(data.points[0].y - data.points[data.pointslength].y);
+          let distance = Math.sqrt(Math.pow(dx,2)+Math.pow(dy,2));
+
+          data.lp.x = (data.points[0].x-data.points[data.pointslength].x)*data.lengthFact/distance+origin.railpoint[0].x;
+          data.lp.z = (data.points[0].y-data.points[data.pointslength].y)*data.lengthFact/distance+origin.railpoint[0].z;
+
+          data.rp.x = origin.railpoint[0].x;
+          data.rp.z = origin.railpoint[0].z;
+
+
+          let axix = new THREE.Vector3(1,0,0);
+          let axixnow = new THREE.Vector3(data.rp.x-data.lp.x,0,data.rp.z-data.lp.z);
+          let rotenum = axixnow.angleTo(axix);
+          //不同坐标系方向值不同
+          if(data.points[0].y>data.points[data.pointslength].y){
+            initRotation = 0.2678;
+            data.lp.x = data.rp.x - (data.lengthFact)*Math.cos(initRotation);
+            data.lp.z = data.rp.z + (data.lengthFact)*Math.sin(initRotation);
+          }else if(data.points[0].y<data.points[data.pointslength].y){
+            initRotation = -0.2678;
+            data.lp.x = data.rp.x - (data.lengthFact)*Math.cos(initRotation);
+            data.lp.z = data.rp.z + (data.lengthFact)*Math.sin(initRotation);
+          }else{
+            data.lp.z = data.rp.z;
+          }
+
+
+        }
+        if(data.ctype == "3" || data.ctype == "4"){
+          let dx = Math.abs(data.points[0].x - data.points[data.pointslength].x);
+          let dy = Math.abs(data.points[0].y - data.points[data.pointslength].y);
+          let distance = Math.sqrt(Math.pow(dx,2)+Math.pow(dy,2));
+
+          data.rp.x = (data.points[data.pointslength].x-data.points[0].x)*data.lengthFact/distance+origin.railpoint[2].x;
+          data.rp.z = (data.points[data.pointslength].y-data.points[0].y)*data.lengthFact/distance+origin.railpoint[2].z;
+
+          data.lp.x = origin.railpoint[2].x;
+          data.lp.z = origin.railpoint[2].z;
+          let axix = new THREE.Vector3(1,0,0);
+          let axixnow = new THREE.Vector3(data.rp.x-data.lp.x,0,data.rp.z-data.lp.z);
+          let rotenum = axixnow.angleTo(axix);
+          //不同坐标系方向值不同
+          if(data.points[0].y>data.points[data.pointslength].y){
+            initRotation = 0.2678;
+            data.rp.x = data.lp.x+(data.lengthFact)*Math.cos(initRotation);
+            data.rp.z = data.lp.z-(data.lengthFact)*Math.sin(initRotation);
+          }else if(data.points[0].y<data.points[data.pointslength].y){
+            initRotation = -0.2678;
+            data.rp.x = data.lp.x+(data.lengthFact)*Math.cos(initRotation);
+            data.rp.z = data.lp.z-(data.lengthFact)*Math.sin(initRotation);
+          }else{
+            data.lp.z = data.rp.z;
+          }
+        }
+        closedSpline = new THREE.CatmullRomCurve3( [
+          new THREE.Vector3(data.lp.x,0,data.lp.z),
+          new THREE.Vector3((data.lp.x+data.rp.x)/2,0,(data.lp.z+data.rp.z)/2-0.001),
+          new THREE.Vector3(data.rp.x,0,data.rp.z),
+        ] );
+        data.railpoint = [
+          new THREE.Vector3(data.lp.x,0,data.lp.z),
+          new THREE.Vector3((data.lp.x+data.rp.x)/2,0,(data.lp.z+data.rp.z)/2-0.001),
+          new THREE.Vector3(data.rp.x,0,data.rp.z),
+        ];
+
+      }
+
+
+
+      closedSpline.type = 'catmullrom';
+      closedSpline.closed = false;
+      var extrudeSettings = {
+          steps           : 5,
+          curveSegments   : 1,
+          bevelSegments   : 1,
+          bevelEnabled    : false,
+          extrudePath     : closedSpline,
+      };
+      var shape = new THREE.Shape();
+      shape.moveTo( 0,-2 );
+      shape.lineTo( 0, 2 );
+      var geometry = new THREE.ExtrudeBufferGeometry( shape, extrudeSettings );
+
+
+      var randomMaterail = new THREE.MeshLambertMaterial({
+          //color:color.fromArray(colorArray)
+          color:0xFFFFFF*Math.random()
+      })
+      let testmesh2 = new THREE.Mesh( geometry, randomMaterail );
+      testmesh2.railpoint = data.railpoint;
+
+      testmesh2.lengthFact = data.lengthFact;
+      // closedSpline.arcLengthDivisions;
+      let count = testmesh2.geometry.attributes.position.count/3;
+
+      for(let i=0;i<count;i++){
+        let ui=i*6;
+        if(i%2 != 0){
+          testmesh2.geometry.attributes.uv.array[ui] = 0;
+          testmesh2.geometry.attributes.uv.array[ui+1] = 1;
+          testmesh2.geometry.attributes.uv.array[ui+2] = len/5;
+          testmesh2.geometry.attributes.uv.array[ui+3] = 1;
+          testmesh2.geometry.attributes.uv.array[ui+4] = len/5;
+          testmesh2.geometry.attributes.uv.array[ui+5] = 0;
+        }else{
+          testmesh2.geometry.attributes.uv.array[ui] = 0;
+          testmesh2.geometry.attributes.uv.array[ui+1] = 0;
+          testmesh2.geometry.attributes.uv.array[ui+2] = 0;
+          testmesh2.geometry.attributes.uv.array[ui+3] = 1;
+          testmesh2.geometry.attributes.uv.array[ui+4] = len/5;
+          testmesh2.geometry.attributes.uv.array[ui+5] = 0;
+        }
+      }
+
+
+      testmesh2.code = data.code;
+      testmesh2.lengthFact = data.lengthFact;
+      scope.sectiongroup.add( testmesh2 );
+
+
+      data.mesh = testmesh2;
+    }
+
+    // var box = new THREE.BoxHelper( testmesh2, 0xffffff );
+    //  scope.sectiongroup.add( box );
+
+  }
+  this.loadpromise = function(jlmap3ddata,assetloader,sectiondata,scene){
+    // console.log("-------------------");
+    // console.log(jlmap3ddata.sectionlist.sections.datalist);
+    // console.log(sectiondata);
+    var texture = new THREE.TextureLoader().load( '../../static/test/z0251.png' );
+        texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+        texture.repeat.set( 1,1);
+
+    var selectmaterial = new THREE.MeshPhongMaterial( { map: texture,transparent:true,alphaTest:0.1 } );
+
+
+    scene.add(scope.sectiongroup);
+    return new Promise(function(resolve, reject){
+      for(let i=0,leni = sectiondata.length;i<leni;i++){
+        let newsection = {
+          code:sectiondata[i].code,
+          name:sectiondata[i].name,
+          standTrack:sectiondata[i].standTrack,
+          // rail:sectiondata[i].rail,
+          lengthFact:sectiondata[i].lengthFact,
+          // rp:sectiondata[i].rp,
+          // lp:sectiondata[i].lp,
+          railpoint:sectiondata[i].railpoint,
+          mesh:null
+        };
+
+        let testmesh2 = null;
+        if(newsection.standTrack == true){
+
+
+        }
+        if(newsection.railpoint.length>2){
+
+            // console.log(newsection);
+            console.log("=======================");
+            if(newsection.code == "T27"){
+              console.log(newsection.railpoint[0]);
+              console.log(newsection.railpoint[1]);
+              console.log(newsection.railpoint[2]);
+            }
+            let height = Math.random()/1000;
+            var closedSpline = new THREE.CatmullRomCurve3( [
+              new THREE.Vector3(newsection.railpoint[0].x,height,newsection.railpoint[0].z),
+              new THREE.Vector3(newsection.railpoint[1].x,height,newsection.railpoint[1].z+0.0001),
+              new THREE.Vector3(newsection.railpoint[2].x,height,newsection.railpoint[2].z)
+            ] );
+            closedSpline.type = 'catmullrom';
+            closedSpline.closed = false;
+            var extrudeSettings = {
+                steps           : 5,
+                curveSegments   : 1,
+                bevelSegments   : 1,
+                bevelEnabled    : false,
+                extrudePath     : closedSpline,
+            };
+            var shape = new THREE.Shape();
+            shape.moveTo( 0,-2 );
+            shape.lineTo( 0, 2 );
+            var geometry = new THREE.ExtrudeBufferGeometry( shape, extrudeSettings );
+            var randomMaterail = new THREE.MeshLambertMaterial({
+                //color:color.fromArray(colorArray)
+                color:0xFFFFFF*Math.random()
+            });
+
+            // if(newsection.standTrack == false){
+            //   testmesh2 = new THREE.Mesh( geometry, randomMaterail );
+            // }else{
+              testmesh2 = new THREE.Mesh( geometry, selectmaterial );
+            // }
+
+            testmesh2.railpoint = [
+              {x:newsection.railpoint[0].x,y:height,z:newsection.railpoint[0].z},
+              {x:newsection.railpoint[1].x,y:height,z:newsection.railpoint[1].z},
+              {x:newsection.railpoint[2].x,y:height,z:newsection.railpoint[2].z},
+            ];
+            testmesh2.lengthFact = newsection.railpoint[2].x-newsection.railpoint[0].x;
+            let len = testmesh2.lengthFact;
+            // testmesh2.lengthFact = newsection.lengthFact;
+            // let len = newsection.lengthFact;
+            // closedSpline.arcLengthDivisions;
+            let count = testmesh2.geometry.attributes.position.count/3;
+
+            for(let i=0;i<count;i++){
+              let ui=i*6;
+              if(i%2 != 0){
+                testmesh2.geometry.attributes.uv.array[ui] = 0;
+                testmesh2.geometry.attributes.uv.array[ui+1] = 1;
+                testmesh2.geometry.attributes.uv.array[ui+2] = len/5;
+                testmesh2.geometry.attributes.uv.array[ui+3] = 1;
+                testmesh2.geometry.attributes.uv.array[ui+4] = len/5;
+                testmesh2.geometry.attributes.uv.array[ui+5] = 0;
+              }else{
+                testmesh2.geometry.attributes.uv.array[ui] = 0;
+                testmesh2.geometry.attributes.uv.array[ui+1] = 0;
+                testmesh2.geometry.attributes.uv.array[ui+2] = 0;
+                testmesh2.geometry.attributes.uv.array[ui+3] = 1;
+                testmesh2.geometry.attributes.uv.array[ui+4] = len/5;
+                testmesh2.geometry.attributes.uv.array[ui+5] = 0;
+              }
+            }
+
+          if(testmesh2){
+            testmesh2.code = newsection.code;
+            testmesh2.standTrack = newsection.standTrack;
+            testmesh2.meshtype = "section";
+
+            // testmesh2.geometry.computeBoundingBox();
+            // testmesh2.geometry.center()
+            // testmesh2.position.set(sectiondata[i].position.x,sectiondata[i].position.y,sectiondata[i].position.z);
+            scope.sectiongroup.add(testmesh2);
+            newsection.mesh = testmesh2;
+            scope.sections.datalist[newsection.code] = newsection;
+          }
+
+        }else{
+          let height = Math.random()/1000;
+          var closedSpline = new THREE.CatmullRomCurve3( [
+            new THREE.Vector3(newsection.railpoint[0].x,height,newsection.railpoint[0].z),
+            new THREE.Vector3((newsection.railpoint[0].x+newsection.railpoint[1].x)/2,height,newsection.railpoint[0].z+0.0001),
+            new THREE.Vector3(newsection.railpoint[1].x,height,newsection.railpoint[1].z)
+          ] );
+          closedSpline.type = 'catmullrom';
+          closedSpline.closed = false;
+          var extrudeSettings = {
+              steps           : 5,
+              curveSegments   : 1,
+              bevelSegments   : 1,
+              bevelEnabled    : false,
+              extrudePath     : closedSpline,
+          };
+          var shape = new THREE.Shape();
+          shape.moveTo( 0,-2 );
+          shape.lineTo( 0, 2 );
+          var geometry = new THREE.ExtrudeBufferGeometry( shape, extrudeSettings );
+          var randomMaterail = new THREE.MeshLambertMaterial({
+              //color:color.fromArray(colorArray)
+              color:0xFFFFFF*Math.random()
+          });
+
+          // if(newsection.standTrack == false){
+          //   testmesh2 = new THREE.Mesh( geometry, randomMaterail );
+          // }else{
+            testmesh2 = new THREE.Mesh( geometry, selectmaterial );
+          // }
+
+          testmesh2.railpoint = [
+            {x:newsection.railpoint[0].x,y:height,z:newsection.railpoint[0].z},
+            {x:(newsection.railpoint[0].x+newsection.railpoint[1].x)/2,y:height,z:newsection.railpoint[1].z},
+            {x:newsection.railpoint[1].x,y:height,z:newsection.railpoint[1].z},
+          ];
+          testmesh2.lengthFact = newsection.railpoint[1].x-newsection.railpoint[0].x;
+          let len = testmesh2.lengthFact;
+          // closedSpline.arcLengthDivisions;
+          let count = testmesh2.geometry.attributes.position.count/3;
+
+          for(let i=0;i<count;i++){
+            let ui=i*6;
+            if(i%2 != 0){
+              testmesh2.geometry.attributes.uv.array[ui] = 0;
+              testmesh2.geometry.attributes.uv.array[ui+1] = 1;
+              testmesh2.geometry.attributes.uv.array[ui+2] = len/5;
+              testmesh2.geometry.attributes.uv.array[ui+3] = 1;
+              testmesh2.geometry.attributes.uv.array[ui+4] = len/5;
+              testmesh2.geometry.attributes.uv.array[ui+5] = 0;
+            }else{
+              testmesh2.geometry.attributes.uv.array[ui] = 0;
+              testmesh2.geometry.attributes.uv.array[ui+1] = 0;
+              testmesh2.geometry.attributes.uv.array[ui+2] = 0;
+              testmesh2.geometry.attributes.uv.array[ui+3] = 1;
+              testmesh2.geometry.attributes.uv.array[ui+4] = len/5;
+              testmesh2.geometry.attributes.uv.array[ui+5] = 0;
+            }
+          }
+
+          if(testmesh2){
+            testmesh2.code = newsection.code;
+            testmesh2.standTrack = newsection.standTrack;
+            testmesh2.meshtype = "section";
+
+            // testmesh2.geometry.computeBoundingBox();
+            // testmesh2.geometry.center()
+            // testmesh2.position.set(sectiondata[i].position.x,sectiondata[i].position.y,sectiondata[i].position.z);
+            scope.sectiongroup.add(testmesh2);
+            newsection.mesh = testmesh2;
+            scope.sections.datalist[newsection.code] = newsection;
+          }
+        }
+
+
+      }
+      resolve("loadersection");
+    });
+
+  }
+
+}
diff --git a/src/jlmap3d/edit/testEditorModel/SectionModel.js b/src/jlmap3d/edit/testEditorModel/SectionModel.js
new file mode 100644
index 000000000..9ba9abb07
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/SectionModel.js
@@ -0,0 +1,26 @@
+export function  SectionModel(data) {
+	var scope = this;
+	//命名
+	this.name = null;
+	//code
+	this.code = null;
+	//索引位置
+	this.index = null;
+	//轨迹点
+	this.rail = [];
+
+	this.railline = null;
+	//长度
+	this.distance = [];
+
+	this.isStandTrack = null;
+
+	this.type = null;
+	//指向模型
+  this.mesh = null;
+	// //模型地址
+  // this.meshurl = null;
+	// //贴图地址
+  // this.picurl = null;
+
+}
diff --git a/src/jlmap3d/edit/testEditorModel/SignalList.js b/src/jlmap3d/edit/testEditorModel/SignalList.js
new file mode 100644
index 000000000..49e9271c7
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/SignalList.js
@@ -0,0 +1,270 @@
+import {SignalModel} from '@/jlmap3d/edit/editmodel/SignalModel.js';
+
+export function SignalList() {
+
+  let scope = this;
+
+  this.type = "signallist";
+
+  this.list = [];
+
+  this.group = new THREE.Group();
+
+  this.initpromise = function(jlmap3ddata,data,scene,assetloader,netdata){
+    return new Promise(function(resolve, reject){
+      scope.group.name = "signal";
+      // console.log(data);
+      //遍历信号数据
+      let netsignal = null;
+      let haddata = false;
+      if(netdata){
+         netsignal = JSON.parse(netdata);
+         haddata = true;
+      }
+      let sectiondata = jlmap3ddata.sectionlist.sections.datalist;
+      let num;
+      for(let j=0;j<assetloader.modellist.length;j++){
+        if(assetloader.modellist[j].deviceType == "signal"){
+          num = j;
+        }
+      }
+      for(let i=0;i<data.length;i++){
+        if(data[i].virtual == false){
+          let newsignal = new SignalModel(data[i]);
+          if(haddata == false){
+                  // console.log(data[i])
+            let newmesh = assetloader.modellist[num].mesh.clone(true);
+
+            newmesh.name = data[i].name;
+            newmesh.modelid = assetloader.modellist[num].id;
+            newmesh.code = data[i].code;
+            newmesh.sectionCode = data[i].sectionCode;
+            newmesh.right = data[i].right;
+            newmesh.virtual = data[i].virtual;
+            for(let j=0;j<newmesh.children.length;j++){
+              newmesh.children[j].code = data[i].code;
+            }
+            let section = sectiondata[data[i].sectionCode];
+            let posx = null;
+
+            if(data[i].sectionOffset > section.lengthFact/2){
+              posx = section.mesh.position.x + data[i].sectionOffset - section.lengthFact/2;
+            }else{
+              posx = section.mesh.position.x - (section.lengthFact/2 - data[i].sectionOffset);
+            }
+            //根据线路方向修改信号灯位置
+            if(data[i].right == false){
+              if(section.standTrack == true){
+                posx = posx - 7;
+              }
+
+              newmesh.position.set(posx,0,section.mesh.position.z-3);
+              newmesh.rotation.z = ( Math.PI / 2 );
+            }else if(data[i].right == true){
+              if(section.standTrack == true){
+                posx = posx + 7;
+              }
+              newmesh.position.set(posx,0,section.mesh.position.z+3);
+              newmesh.rotation.z = ( - Math.PI / 2 );
+            }
+            newmesh.scale.x = 0.05;
+            newmesh.scale.y = 0.05;
+            newmesh.scale.z = 0.05;
+            newmesh.sectionOffset = data[i].sectionOffset;
+            newmesh.sectionCode = data[i].sectionCode;
+            newmesh.right = data[i].right;
+            newsignal.mesh = newmesh;
+
+            newsignal.sectionOffset = data[i].sectionOffset;
+            newsignal.mesh.status = "01";
+            newsignal.name = data[i].name;
+            newsignal.modelid = assetloader.modellist[num].id;
+            newsignal.code = data[i].code;
+            newsignal.sectionCode = data[i].sectionCode;
+            newsignal.right = data[i].right;
+            scope.group.add(newmesh);
+            scope.list.push(newsignal);
+
+          }else{
+            for(let j=0;j<assetloader.modellist.length;j++){
+              if(assetloader.modellist[j].id == netsignal[i].modelid){
+                num = j;
+              }
+            }
+            let newmesh = assetloader.modellist[num].mesh.clone(true);
+
+            newmesh.uuid = netsignal[i].id;
+            newmesh.name = netsignal[i].name;
+            newmesh.modelid = assetloader.modellist[num].id;
+            newmesh.code = netsignal[i].code;
+            newmesh.virtual = data[i].virtual;
+            for(let j=0;j<newmesh.children.length;j++){
+              newmesh.children[j].code = netsignal[i].code;
+            }
+            newmesh.position.x = netsignal[i].position.x;
+            newmesh.position.y = netsignal[i].position.y;
+            newmesh.position.z = netsignal[i].position.z;
+            newmesh.rotation.x = netsignal[i].rotation._x;
+            newmesh.rotation.y = netsignal[i].rotation._y;
+            newmesh.rotation.z = netsignal[i].rotation._z;
+            newmesh.scale.x = netsignal[i].scale.x;
+            newmesh.scale.y = netsignal[i].scale.y;
+            newmesh.scale.z = netsignal[i].scale.z;
+
+
+            // newsignal.mesh = newmesh;
+            newsignal.mesh.status = "01";
+            scope.group.add(newmesh);
+            scope.list.push(newsignal);
+          }
+
+        }
+
+
+      }
+
+      scene.add(scope.group);
+      resolve("loadedsignal");
+    });
+  }
+
+  this.loadpromise  = function(signaldata,scene,assetloader,data){
+    return new Promise(function(resolve, reject){
+      let num;
+      for(let j=0;j<assetloader.modellist.length;j++){
+        if(assetloader.modellist[j].type == "signal"){
+          num = j;
+        }
+      }
+      for(let i=0;i<signaldata.length;i++){
+        //signaldata[i].virtual == "false"
+        for(let n=0;n<data.length;n++){
+          if(signaldata[i].code == data[n].code){
+            if(data[n].virtual == false){
+              let newsignal = new SignalModel(signaldata[i]);
+
+              // console.log(signaldata[i]);
+              let newmesh = assetloader.modellist[num].mesh.clone(true);
+              newmesh.sectionCode = data[n].sectionCode;
+              newmesh.sectionOffset = data[n].sectionOffset;
+              // newmesh.uuid = signaldata[i].id;
+              for(let j=0;j<newmesh.children.length;j++){
+                newmesh.children[j].code = signaldata[i].code;
+              }
+              newmesh.name = signaldata[i].name;
+              newmesh.modelid = assetloader.modellist[num].id;
+              newmesh.code = signaldata[i].code;
+              newmesh.right = data[n].right;
+              newmesh.virtual = data[n].virtual;
+              newmesh.position.x = signaldata[i].position.x;
+              newmesh.position.y = signaldata[i].position.y;
+              newmesh.position.z = signaldata[i].position.z;
+              newmesh.rotation.x = signaldata[i].rotation._x;
+              newmesh.rotation.y = signaldata[i].rotation._y;
+              newmesh.rotation.z = signaldata[i].rotation._z;
+              newsignal.mesh = newmesh;
+              newsignal.mesh.status = "01";
+
+              scope.group.add(newsignal.mesh);
+              scope.list.push(newsignal);
+              n = data.length;
+            }
+
+          }
+
+        }
+
+      }
+      scene.add(scope.group);
+      resolve("loadedsignal");
+    });
+  };
+  this.resetsignal = function(jlmap3ddata){
+    // console.log(jlmap3ddata.linksgroup);
+    let sectiondata = jlmap3ddata.sectionlist.sectiongroup.children;
+    for(let i=0;i<scope.group.children.length;i++){
+      let signaldata = scope.group.children[i];
+
+      for(let j=0;j<sectiondata.length;j++){
+        if(sectiondata[j].code == signaldata.sectionCode){
+          let section = sectiondata[j];
+          let posx = null;
+          // console.log(section);
+
+          posx = section.railpoint[0].x + signaldata.sectionOffset;
+
+          //根据线路方向修改信号灯位置
+          if(signaldata.right == false){
+            if(section.standTrack == true){
+              posx = posx - 7;
+            }
+
+            signaldata.position.set(posx,0,section.railpoint[0].z-3);
+            signaldata.rotation.z = ( Math.PI / 2 );
+          }else if(signaldata.right == true){
+            if(section.standTrack == true){
+              posx = posx + 7;
+            }
+            signaldata.position.set(posx,0,section.railpoint[0].z+3);
+            signaldata.rotation.z = ( - Math.PI / 2 );
+          }
+          j = sectiondata.length;
+        }
+      }
+
+    }
+  };
+  this.init = function(data,realsectionlist,scene,assetloader){
+
+
+    scope.group.name = "signal";
+    //遍历信号数据
+    for(let i=0;i<data.length;i++){
+      let newsignal = new SignalModel(data);
+
+      let newmesh = assetloader.modellist[0].mesh.clone(true);
+
+      newmesh.name = assetloader.modellist[0].id;
+      newmesh.code = data[i].code;
+      for(let j=0;j<newmesh.children.length;j++){
+        newmesh.children[j].code = data[i].code;
+      }
+
+      //根据线路方向修改信号灯位置
+      if(data[i].directionType == "01"){
+        newmesh.position.set(data[i].position.x,1,data[i].position.y-10);
+        newmesh.rotation.z = ( Math.PI / 2 );
+      }else if(data[i].directionType == "02"){
+        newmesh.position.set(data[i].position.x,1,data[i].position.y+10);
+        newmesh.rotation.z = ( - Math.PI / 2 );
+      }
+      //newmesh.scale.set(0.1,0.1,0.1);
+      newsignal.mesh = newmesh;
+      newsignal.mesh.status = "01";
+      scope.group.add(newsignal.mesh);
+      scope.list.push(newsignal);
+
+    }
+    scene.add(scope.group);
+  }
+
+  this.reposition = function(){
+
+  }
+
+  this.update = function(){
+
+  }
+
+  this.renderon = function(){
+
+  }
+
+  this.renderoff = function(){
+
+  }
+
+  this.dispose = function(){
+
+  }
+}
diff --git a/src/jlmap3d/edit/testEditorModel/SignalModel.js b/src/jlmap3d/edit/testEditorModel/SignalModel.js
new file mode 100644
index 000000000..5bc2ce296
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/SignalModel.js
@@ -0,0 +1,36 @@
+export function SignalModel(data) {
+
+  this.uuid = null;
+  this.code = null;
+  this.name = null;
+  this.modelid = null;
+  this.type = null;
+  this.direction = null;
+  this.ismodel = false;
+  this.istexture = false;
+  this.modelurl = null;
+  // this.textures = {
+  //   red:null,
+  //   yellor:null,
+  //   green:null
+  // }
+  // this.position = {
+  //   x:0,
+  //   y:0,
+  //   z:0
+  // };
+  // this.rotation = {
+  //   x:0,
+  //   y:0,
+  //   z:0
+  // };
+  // this.scale = {
+  //   x:0,
+  //   y:0,
+  //   z:0
+  // }
+
+  this.mesh = null;
+  this.meshurl = null;
+  this.picurl = null;
+}
diff --git a/src/jlmap3d/edit/testEditorModel/StationStandList.js b/src/jlmap3d/edit/testEditorModel/StationStandList.js
new file mode 100644
index 000000000..336482c88
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/StationStandList.js
@@ -0,0 +1,228 @@
+import {StationStandModel} from '@/jlmap3d/edit/testEditorModel/StationStandModel.js';
+
+export function StationStandList() {
+
+  let scope = this;
+
+  this.type = "stationstandlist";
+
+  this.list = [];
+
+  this.group = new THREE.Group();
+
+  this.textlist = [];
+
+  this.initpromise = function(jlmap3ddata,stationdata,stationstanddata,scene,assetloader,netdata){
+
+    return new Promise(function(resolve, reject){
+
+      let netstand = null;
+      let haddata = false;
+      if(netdata){
+         haddata = true;
+      }
+      scope.group.name = "station";
+      scene.add(scope.group);
+      //遍历车站数据
+      for(let i=0;i<stationdata.length;i++){
+
+        let newstationstand = new StationStandModel(stationdata[i]);
+        //判断站台是否显示
+
+        if(stationdata[i].visible == true){
+
+          //遍历车站站台数据
+          for(let j=0;j<stationstanddata.length;j++){
+
+            if(stationstanddata[j].small == false){
+              //收集有效车站数据
+              if(stationstanddata[j].stationCode == stationdata[i].code){
+                newstationstand.name = stationdata[i].name;
+
+                newstationstand.code = stationdata[i].code;
+
+                newstationstand.inside = stationstanddata[i].inside;
+                let stand= {
+                  code : stationstanddata[j].code,
+                  position : stationstanddata[j].position,
+                  name : stationstanddata[j].name,
+                  right : stationstanddata[j].right,
+                  section : stationstanddata[j].standTrackCode,
+                  inside : stationstanddata[j].inside,
+              	};
+                newstationstand.stands.push(stand);
+                // //向右上行
+                // if(stationstanddata[j].right == true){
+                //   newstationstand.direction1.code = stationstanddata[j].code;
+                //   newstationstand.direction1.position = stationstanddata[j].position;
+                //   newstationstand.direction1.name = stationstanddata[j].name;
+                //   newstationstand.direction1.screenDoorOpenStatus = "01";
+                //   newstationstand.direction1.section = stationstanddata[j].standTrackCode;
+                //   newstationstand.direction1.inside = stationstanddata[j].inside;
+                // }
+                // //向左下行
+                // if(stationstanddata[j].right == false){
+                //   newstationstand.direction2.code = stationstanddata[j].code;
+                //   newstationstand.direction2.position = stationstanddata[j].position;
+                //   newstationstand.direction2.name = stationstanddata[j].name;
+                //   newstationstand.direction2.screenDoorOpenStatus = "01";
+                //   newstationstand.direction2.section = stationstanddata[j].standTrackCode;
+                //   newstationstand.direction2.inside = stationstanddata[j].inside;
+                // }
+              }
+            }
+
+          }
+
+          if(newstationstand.code != null){
+            scope.list.push(newstationstand);
+          }
+
+        }
+
+      }
+
+      resolve("loadedstation");
+    });
+  }
+  this.loadpromise = function(jlmap3ddata,standsdata,jlmapstanddata,scene,assetloader){
+    return new Promise(function(resolve, reject){
+      // console.log(jlmap3ddata);
+      // console.log(standsdata);
+      // console.log(jlmapstanddata);
+      let stations = jlmap3ddata.stationstandlist.list;
+      let num;
+      let num2;
+      let num3;
+      for(let j=0;j<assetloader.modellist.length;j++){
+        if(assetloader.modellist[j].type == "stationInside"){
+          num = j;
+        }
+        if(assetloader.modellist[j].type == "stationOutside"){
+          num2 = j;
+        }
+        if(assetloader.modellist[j].type == "stationThree"){
+          num3 = j;
+        }
+
+
+        if(assetloader.modellist[j].deviceType == "stand"){
+          num = j;
+        }
+        if(assetloader.modellist[j].deviceType == "standwaice"){
+          num2 = j;
+          // assetloader.modellist[num2].mesh.rotation.y = Math.PI/2;
+        }
+        if(assetloader.modellist[j].deviceType == "station3"){
+          num3 = j;
+        }
+      }
+      // console.log("+++++++++++++");
+      // console.log(jlmapstanddata);
+      // console.log(standsdata);
+      for(let i=0;i<standsdata.length;i++){
+        let newstationstand = new StationStandModel(standsdata[i]);
+        let newstationmesh;
+        let stands = [];
+        console.log("--------------------");
+        for(let j=0;j<jlmapstanddata.length;j++){
+          if(jlmapstanddata[j].stationCode == standsdata[i].code && jlmapstanddata[j].small != true){
+            console.log(jlmapstanddata[j]);
+            let changestand = {
+              code : jlmapstanddata[j].code,
+              position : jlmapstanddata[j].position,
+              name : jlmapstanddata[j].name,
+              right : jlmapstanddata[j].right,
+              section : jlmapstanddata[j].standTrackCode,
+              inside : jlmapstanddata[j].inside,
+            };
+            stands.push(changestand);
+          }
+        }
+        newstationstand.stands = stands;
+        if(newstationstand.stands.length<=2){
+
+          if(standsdata[i].inside == true){
+            newstationmesh = assetloader.modellist[num].mesh.clone(true);
+          }else{
+            newstationmesh = assetloader.modellist[num2].mesh.clone(true);
+          }
+          // console.log(jlmapstanddata[j]);
+          newstationstand.code = standsdata[i].code;
+          newstationstand.name = standsdata[i].name;
+          newstationstand.inside = standsdata[i].inside;
+          // console.log(standsdata[i]);
+          newstationmesh.position.x = standsdata[i].position.x;
+          newstationmesh.position.y = standsdata[i].position.y;
+          newstationmesh.position.z = standsdata[i].position.z;
+          // newstationmesh.rotation.x = standsdata[i].rotation._x;
+          // newstationmesh.rotation.y = standsdata[i].rotation._y;
+          // newstationmesh.rotation.z = standsdata[i].rotation._z;
+          newstationstand.mesh = newstationmesh;
+          scope.group.add(newstationmesh);
+          scope.list.push(newstationstand);
+        }else{
+          newstationmesh = assetloader.modellist[num3].mesh.clone(true);
+          // console.log(jlmapstanddata[j]);
+          newstationstand.code = standsdata[i].code;
+          newstationstand.name = standsdata[i].name;
+          newstationstand.inside = standsdata[i].inside;
+          // console.log(standsdata[i]);
+          newstationmesh.position.x = standsdata[i].position.x;
+          newstationmesh.position.y = standsdata[i].position.y;
+          newstationmesh.position.z = standsdata[i].position.z;
+          // newstationmesh.rotation.x = standsdata[i].rotation._x;
+          // newstationmesh.rotation.y = standsdata[i].rotation._y;
+          // newstationmesh.rotation.z = standsdata[i].rotation._z;
+          newstationstand.mesh = newstationmesh;
+          scope.group.add(newstationmesh);
+          scope.list.push(newstationstand);
+        }
+      }
+      scene.add(scope.group);
+      resolve("loadedstation");
+    });
+
+  }
+  this.update = function(){
+
+  }
+
+  this.renderon = function(){
+
+  }
+
+  this.renderoff = function(){
+
+  }
+
+  this.dispose = function(){
+
+  }
+
+}
+//canvas文字贴图方法
+//PS:待提炼 增强功能
+function getTextCanvas(text){
+  var canvas = document.getElementById('canvastexture');
+  // let width = 128;
+  // let height = 64;
+  // canvas.style.width = width + "px";
+  // canvas.style.height = height + "px";
+
+  var ctx = canvas.getContext('2d');
+  ctx.fillStyle = '#FFFFFF';
+  ctx.fillRect(0, 0,128,64);
+  ctx.font = "500px";
+  ctx.fillStyle = '#000000';
+  ctx.textAlign = 'center';
+  ctx.textBaseline = 'middle';
+  ctx.clearRect(0,0,128,64);
+
+  ctx.fillText(text.name, 128/2,64/4);
+  ctx.fillText(text.runPlanName, 128/2,64*2/4);
+  ctx.fillText(text.kmPost, 128/2,64*3/4);
+
+  let data = ctx.getImageData(0, 0,128,64);
+  return data;
+}
diff --git a/src/jlmap3d/edit/testEditorModel/StationStandModel.js b/src/jlmap3d/edit/testEditorModel/StationStandModel.js
new file mode 100644
index 000000000..898b1fbf7
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/StationStandModel.js
@@ -0,0 +1,21 @@
+export function StationStandModel(opts) {
+
+	var scope = this;
+
+	this.uuid = null;
+	this.code = null;
+	this.name = null;
+	this.modelid = null;
+	this.type = null;
+
+	this.ismodel = false;
+	this.istexture = false;
+	this.modelurl = null;
+
+	this.stands = [];
+	
+
+  this.mesh = null;
+  this.meshurl = null;
+  this.picurl = null;
+}
diff --git a/src/jlmap3d/edit/testEditorModel/SwitchList.js b/src/jlmap3d/edit/testEditorModel/SwitchList.js
new file mode 100644
index 000000000..b66bbedf8
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/SwitchList.js
@@ -0,0 +1,135 @@
+import {SwitchModel} from '@/jlmap3d/edit/neweditmodel/SwitchModel.js';
+
+export function SwitchList() {
+
+  let scope = this;
+  this.type = "switchlist";
+
+  this.switchgroup = new THREE.Group();
+  this.switchgroup.name = "switch";
+
+  this.switchs = {
+    datalist:[],
+    modellist:[]
+  };
+
+  this.initpromise = function(jlmap3ddata,data,scene,assetloader,netdata){
+    // console.log(jlmap3ddata);
+    return new Promise(function(resolve, reject){
+      scene.add( scope.switchgroup );
+      let sectiondata = jlmap3ddata.sectionlist.sections.datalist;
+      // console.log(sectiondata);
+      let num;
+      for(let j=0;j<assetloader.modellist.length;j++){
+        if(assetloader.modellist[j].deviceType == "autoswitch"){
+          num = j;
+        }
+      };
+      for(let i=0,leni = data.length;i<leni;i++){
+
+        let newswitch = {
+          code:data[i].code,
+          name:data[i].name,
+          pa:data[i].sectionACode,
+          pb:data[i].sectionBCode,
+          pc:data[i].sectionCCode
+        };
+
+        let autoswitch = assetloader.modellist[num].mesh.clone(true);
+        autoswitch.code = data[i].code;
+        scope.switchs.datalist.push(newswitch);
+        scope.switchs.modellist.push(autoswitch);
+        scope.switchgroup.add(autoswitch);
+        if(sectiondata[data[i].sectionACode].mesh.position.x >sectiondata[data[i].sectionBCode].mesh.position.x){
+          autoswitch.position.set(sectiondata[data[i].sectionACode].lp.x,0,sectiondata[data[i].sectionACode].lp.z);
+            autoswitch.rotation.z = Math.PI;
+        }else{
+          autoswitch.position.set(sectiondata[data[i].sectionACode].rp.x,0,sectiondata[data[i].sectionACode].rp.z);
+
+        }
+      }
+
+      resolve("loadedswitch");
+    });
+
+  }
+
+  this.loadpromise = function(jlmap3ddata,switchdata,scene,assetloader){
+    return new Promise(function(resolve, reject){
+      scene.add( scope.switchgroup );
+      // let sectiondata = jlmap3ddata.sectionlist.sections.datalist;
+      // console.log(sectiondata);
+      let num;
+      for(let j=0;j<assetloader.modellist.length;j++){
+        if(assetloader.modellist[j].type == "switch"){
+          num = j;
+        }
+
+        if(assetloader.modellist[j].deviceType == "autoswitch"){
+          num = j;
+        }
+      };
+      for(let i=0,leni = switchdata.length;i<leni;i++){
+        // console.log(switchdata[i]);
+        let newswitch = {
+          code:switchdata[i].code,
+          name:switchdata[i].name,
+          pa:switchdata[i].pa,
+          pb:switchdata[i].pb,
+          pc:switchdata[i].pc
+        };
+
+        // console.log(newswitch.pa);
+        let autoswitch = assetloader.modellist[num].mesh.clone(true);
+        autoswitch.code = switchdata[i].code;
+        for(let j=0;j<autoswitch.children.length;j++){
+          autoswitch.children[j].code = switchdata[i].code;
+        }
+        scope.switchs.datalist.push(newswitch);
+        scope.switchs.modellist.push(autoswitch);
+        scope.switchgroup.add(autoswitch);
+        autoswitch.position.set(switchdata[i].position.x,switchdata[i].position.y,switchdata[i].position.z);
+        autoswitch.rotation.x = switchdata[i].rotation._x;
+        autoswitch.rotation.y = switchdata[i].rotation._y;
+        autoswitch.rotation.z = switchdata[i].rotation._z;
+
+      }
+
+      resolve("loadedswitch");
+    });
+
+  }
+
+  this.resetswitch = function(data){
+    // console.log("reset");
+    let sectiondata = data.sectionlist.sectiongroup;
+    for(let i=0;i<scope.switchs.datalist.length;i++){
+
+      let sectionA = sectiondata.getObjectByProperty("code",scope.switchs.datalist[i].pa);
+      let sectionB = sectiondata.getObjectByProperty("code",scope.switchs.datalist[i].pb);
+
+      if(sectionA.railpoint[0].x > sectionB.railpoint[0].x){
+        scope.switchs.modellist[i].position.set(sectionA.railpoint[0].x,0,sectionA.railpoint[0].z);
+      }else{
+        scope.switchs.modellist[i].position.set(sectionA.railpoint[1].x,0,sectionA.railpoint[1].z);
+      }
+    }
+  }
+
+  this.update = function(){
+
+  }
+
+  this.renderon = function(){
+
+  }
+
+  this.renderoff = function(){
+
+  }
+
+  this.dispose = function(){
+
+  }
+
+}
diff --git a/src/jlmap3d/edit/testEditorModel/SwitchModel.js b/src/jlmap3d/edit/testEditorModel/SwitchModel.js
new file mode 100644
index 000000000..bd8e452a3
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/SwitchModel.js
@@ -0,0 +1,22 @@
+export function SwitchModel() {
+
+  var scope = this;
+  //命名
+  this.name = null;
+  //code
+  this.code = null;
+  //索引位置
+  this.index = null;
+  //轨迹点
+  this.rail = [];
+  //长度
+  this.distance = null;
+
+  this.action = null;
+  //指向模型
+  this.mesh = null;
+  // //模型地址
+  // this.meshurl = null;
+  // //贴图地址
+  // this.picurl = null;
+}
diff --git a/src/jlmap3d/edit/testEditorModel/TrainModel.js b/src/jlmap3d/edit/testEditorModel/TrainModel.js
new file mode 100644
index 000000000..7bf6a92cb
--- /dev/null
+++ b/src/jlmap3d/edit/testEditorModel/TrainModel.js
@@ -0,0 +1,8 @@
+export function TrainModel(opts) {
+
+	var scope = this;
+
+  this.mesh = null;
+  this.meshurl = null;
+  this.picurl = null;
+}
diff --git a/src/jlmap3d/main/loaders/DriverLoadNew.js b/src/jlmap3d/main/loaders/DriverLoadNew.js
index a67f76d68..801b725eb 100644
--- a/src/jlmap3d/main/loaders/DriverLoadNew.js
+++ b/src/jlmap3d/main/loaders/DriverLoadNew.js
@@ -106,19 +106,25 @@ export function DriverLoadNew(data,scope,netdata,mapdata,sectionlist,signallist,
         if(scope.stationtexture["stationlist"]){
           for(let mm=0;mm< stationstandlist.group.children.length;mm++){
             let stationname = stationstandlist.group.children[mm].name;
-            stationstandlist.group.children[mm].getObjectByName("zhantailiebiao").material.map =scope.stationtexture["stationlist"];
-            stationstandlist.group.children[mm].getObjectByName("zhantailiebiao").material.map.needsUpdate = true;
+            if(stationstandlist.group.children[mm].getObjectByName("zhantailiebiao")){
+              stationstandlist.group.children[mm].getObjectByName("zhantailiebiao").material.map =scope.stationtexture["stationlist"];
+              stationstandlist.group.children[mm].getObjectByName("zhantailiebiao").material.map.needsUpdate = true;
+
+            }
             if(stationstandlist.group.children[mm].getObjectByName("menkuangyanse")){
               stationstandlist.group.children[mm].getObjectByName("menkuangyanse").material.map =scope.stationtexture["pingbimen"];
               stationstandlist.group.children[mm].getObjectByName("menkuangyanse").material.map.needsUpdate = true;
             }
 
 
-            let newmaterial = stationstandlist.group.children[mm].getObjectByName("zhantaiming").material.clone();
-            newmaterial.map =scope.stationtexture[stationname];
 
-            stationstandlist.group.children[mm].getObjectByName("zhantaiming").material = newmaterial;
-            stationstandlist.group.children[mm].getObjectByName("zhantaiming").material.map.needsUpdate = true;
+            if(stationstandlist.group.children[mm].getObjectByName("zhantaiming")){
+              let newmaterial = stationstandlist.group.children[mm].getObjectByName("zhantaiming").material.clone();
+              newmaterial.map =scope.stationtexture[stationname];
+              stationstandlist.group.children[mm].getObjectByName("zhantaiming").material = newmaterial;
+              stationstandlist.group.children[mm].getObjectByName("zhantaiming").material.map.needsUpdate = true;
+            }
+
           }
 
         }
diff --git a/src/jlmap3d/main/loaders/SimulationLoadNew.js b/src/jlmap3d/main/loaders/SimulationLoadNew.js
index 774bd81c7..d4fd3a759 100644
--- a/src/jlmap3d/main/loaders/SimulationLoadNew.js
+++ b/src/jlmap3d/main/loaders/SimulationLoadNew.js
@@ -47,7 +47,8 @@ export function SimulationLoadNew(data,scope,netdata,mapdata,camera,controls,sce
   }
 
   function initnew3d(data,netdata){
-    
+    // console.log(JSON.parse());
+    // console.log(netdata);
     // console.log(JSON.parse(netdata.assets));
     Materialload(scope,JSON.parse(netdata.assets).stationTextureList[0]);
     let mapdata = data;
@@ -130,22 +131,28 @@ export function SimulationLoadNew(data,scope,netdata,mapdata,camera,controls,sce
 
         if(scope.stationtexture["stationlist"]){
           for(let mm=0;mm< stationstandlist.group.children.length;mm++){
-              let stationname = stationstandlist.group.children[mm].name;
+            let stationname = stationstandlist.group.children[mm].name;
+            if(stationstandlist.group.children[mm].getObjectByName("zhantailiebiao")){
               stationstandlist.group.children[mm].getObjectByName("zhantailiebiao").material.map =scope.stationtexture["stationlist"];
               stationstandlist.group.children[mm].getObjectByName("zhantailiebiao").material.map.needsUpdate = true;
-              // console.log(stationstandlist.group.children[mm].getObjectByName("menkuangyanse"));
-              if(stationstandlist.group.children[mm].getObjectByName("menkuangyanse")){
-                stationstandlist.group.children[mm].getObjectByName("menkuangyanse").material.map =scope.stationtexture["pingbimen"];
-                stationstandlist.group.children[mm].getObjectByName("menkuangyanse").material.map.needsUpdate = true;
-              }
 
+            }
 
+            // console.log(stationstandlist.group.children[mm].getObjectByName("menkuangyanse"));
+            if(stationstandlist.group.children[mm].getObjectByName("menkuangyanse")){
+              stationstandlist.group.children[mm].getObjectByName("menkuangyanse").material.map =scope.stationtexture["pingbimen"];
+              stationstandlist.group.children[mm].getObjectByName("menkuangyanse").material.map.needsUpdate = true;
+            }
+
+            if(stationstandlist.group.children[mm].getObjectByName("zhantaiming")){
               let newmaterial = stationstandlist.group.children[mm].getObjectByName("zhantaiming").material.clone();
               newmaterial.map =scope.stationtexture[stationname];
 
               stationstandlist.group.children[mm].getObjectByName("zhantaiming").material = newmaterial;
               stationstandlist.group.children[mm].getObjectByName("zhantaiming").material.map.needsUpdate = true;
 
+            }
+
           }
 
 
diff --git a/src/jlmap3d/main/newmodel/SectionListN.js b/src/jlmap3d/main/newmodel/SectionListN.js
index 81ef66cad..6a68ddc1f 100644
--- a/src/jlmap3d/main/newmodel/SectionListN.js
+++ b/src/jlmap3d/main/newmodel/SectionListN.js
@@ -96,12 +96,12 @@ this.loadpromise = function(sectionList,sectiondata,rails,scene,assetloader){
       // }
       // testmesh2 = null;
 
-      if(newsection.railpoint.length>2){
+      if(newsection.railpoint.length>=3){
         // console.log(newsection);
         let height = Math.random()/1000;
         var closedSpline = new THREE.CatmullRomCurve3( [
           new THREE.Vector3(newsection.railpoint[0].x,height,newsection.railpoint[0].z),
-          new THREE.Vector3(newsection.railpoint[1].x,height,newsection.railpoint[1].z),
+          new THREE.Vector3(newsection.railpoint[1].x,height,newsection.railpoint[1].z+0.0001),
           new THREE.Vector3(newsection.railpoint[2].x,height,newsection.railpoint[2].z)
 				] );
 
diff --git a/src/jlmap3d/main/newmodel/StationStandListN.js b/src/jlmap3d/main/newmodel/StationStandListN.js
index 09b4518d2..12eb113bc 100644
--- a/src/jlmap3d/main/newmodel/StationStandListN.js
+++ b/src/jlmap3d/main/newmodel/StationStandListN.js
@@ -156,19 +156,20 @@ export function StationStandListN() {
 
       for(let i=0;i<standsdata.length;i++){
         let newstationstand = new StationStandModel(standsdata[i]);
+        console.log(standsdata[i]);
         if(standsdata[i].code != "Station96090"){
           newstationstand.code = standsdata[i].code;
           newstationstand.name = standsdata[i].name;
           newstationstand.type = "station";
           newstationstand.num = i;
-
-          newstationstand.direction1.code = standsdata[i].direction1.code;
-          newstationstand.direction1.name = standsdata[i].direction1.name;
-          newstationstand.direction1.screenDoorOpenStatus = "01";
-
-          newstationstand.direction2.code = standsdata[i].direction2.code;
-          newstationstand.direction2.name = standsdata[i].direction2.name;
-          newstationstand.direction2.screenDoorOpenStatus = "01";
+          newstationstand.stands = standsdata[i].stands;
+          // newstationstand.direction1.code = standsdata[i].direction1.code;
+          // newstationstand.direction1.name = standsdata[i].direction1.name;
+          // newstationstand.direction1.screenDoorOpenStatus = "01";
+          //
+          // newstationstand.direction2.code = standsdata[i].direction2.code;
+          // newstationstand.direction2.name = standsdata[i].direction2.name;
+          // newstationstand.direction2.screenDoorOpenStatus = "01";
           let newstationmesh = null;
           if(standsdata[i].inside == undefined){
             newstationmesh = selectmesh1.clone(true);
@@ -209,19 +210,27 @@ export function StationStandListN() {
               let mixer = new THREE.AnimationMixer(  newstationmesh.children[j] );
 
               for(let n=0;n<psddata.length;n++){
-                if(psddata[n].standCode == newstationstand.direction2.code){
+                for(let m=0;m<newstationstand.stands.length;m++){
+                  console.log("====================");
+                  console.log(newstationstand.stands[m]);
+                  console.log(psddata[n]);
+                  if(psddata[n].standCode == newstationstand.stands[m].code && newstationstand.stands[m].right == false){
 
-                  let key = psddata[n].code;
-                  actionss[key] = {
-                    status:"01",
-                    action:mixer.clipAction( newstationmesh.children[j].animations[0])
-                  };
-                  actionss[key].action.setLoop(THREE.LoopOnce);
-                  actionss[key].action.clampWhenFinished = true;
-                  //actionss[key].play();
-                  mixers.push(mixer);
-                  n = psddata.length;
+                    let key = psddata[n].code;
+                    actionss[key] = {
+                      status:"01",
+                      action:mixer.clipAction( newstationmesh.children[j].animations[0])
+                    };
+                    actionss[key].action.setLoop(THREE.LoopOnce);
+                    actionss[key].action.clampWhenFinished = true;
+                    //actionss[key].play();
+                    mixers.push(mixer);
+                    n = psddata.length;
+                    m = newstationstand.stands.length;
+                  }
                 }
+
+
               }
 
             }
@@ -231,18 +240,24 @@ export function StationStandListN() {
 
               let mixer = new THREE.AnimationMixer( newstationmesh.children[j] );
               for(let n=0;n<psddata.length;n++){
-                if(psddata[n].standCode == newstationstand.direction1.code){
+                for(let m=0;m<newstationstand.stands.length;m++){
+                  console.log("====================");
+                  console.log(newstationstand.stands[m]);
+                  console.log(psddata[n]);
+                  if(psddata[n].standCode == newstationstand.stands[m].code && newstationstand.stands[m].right == true){
+                    let key = psddata[n].code;
+                    actionss[key] = {
+                      status:"01",
+                      action:mixer.clipAction( newstationmesh.children[j].animations[0])
+                    };
+                    actionss[key].action.setLoop(THREE.LoopOnce);
+                    actionss[key].action.clampWhenFinished = true;
+                    //actionss[key].play();
+                    mixers.push(mixer);
+                    n = psddata.length;
+                    m = newstationstand.stands.length;
+                  }
 
-                  let key = psddata[n].code;
-                  actionss[key] = {
-                    status:"01",
-                    action:mixer.clipAction( newstationmesh.children[j].animations[0])
-                  };
-                  actionss[key].action.setLoop(THREE.LoopOnce);
-                  actionss[key].action.clampWhenFinished = true;
-                  //actionss[key].play();
-                  mixers.push(mixer);
-                  n = psddata.length;
                 }
               }
             }
@@ -270,7 +285,7 @@ export function StationStandListN() {
           newstationstand.name = standsdata[i].name;
           newstationstand.type = "station";
           newstationstand.num = i;
-
+          newstationstand.stand = [];
           newstationstand.direction1.code = standsdata[i].direction1.code;
           newstationstand.direction1.name = standsdata[i].direction1.name;
           newstationstand.direction1.screenDoorOpenStatus = "01";
diff --git a/src/jlmap3d/main/newmodel/StationStandModel.js b/src/jlmap3d/main/newmodel/StationStandModel.js
index 5f469795c..27a084ddf 100644
--- a/src/jlmap3d/main/newmodel/StationStandModel.js
+++ b/src/jlmap3d/main/newmodel/StationStandModel.js
@@ -11,7 +11,7 @@ export function StationStandModel(opts) {
 	this.ismodel = false;
 	this.istexture = false;
 	this.modelurl = null;
-
+	this.stands = [];
 	this.direction1= {
 		position:null,
 		name:null,
diff --git a/src/views/jlmap3d/edit/component/menu.vue b/src/views/jlmap3d/edit/component/menu.vue
index 8159aa2dc..e58fa9492 100644
--- a/src/views/jlmap3d/edit/component/menu.vue
+++ b/src/views/jlmap3d/edit/component/menu.vue
@@ -16,7 +16,7 @@
 
         <el-button type="expo" @click="expo">导出obj</el-button>
 
-        <el-button type="save" @click="save">保存</el-button>
+        <el-button type="save" @click="save">新地图初始化保存</el-button>
 
         <el-button type="savetest" @click="savetest">测试中保存</el-button>
 
diff --git a/src/views/jlmap3d/edit/jlmap3dedit.vue b/src/views/jlmap3d/edit/jlmap3dedit.vue
index ebf29313a..54ef4accf 100644
--- a/src/views/jlmap3d/edit/jlmap3dedit.vue
+++ b/src/views/jlmap3d/edit/jlmap3dedit.vue
@@ -38,7 +38,7 @@
 
   import axios from 'axios';
   import { update3dMapData } from '@/api/jlmap3d/load3ddata'
-  import { getmodels } from '@/jlmap3d/edit/connect/newgetmodels';
+  import { initDataSave } from '@/jlmap3d/edit/connect/initDataSave';
   import { testgetmodels } from '@/jlmap3d/edit/connect/testgetmodels';
   //components
   import EditProperty from '@/views/jlmap3d/edit/component/property';
@@ -189,11 +189,12 @@
       save() {
         //console.log("save");
         console.log(this.jlmap3dedit.assetManager);
-        let param = getmodels(this.jlmap3dedit);
+        let param = initDataSave(this.jlmap3dedit);
+        console.log(param);
         update3dMapData(param).then(data => {
           //console.log(data);
           if (data.code == "200") {
-            alert("保存成功");
+            alert("初始化保存成功");
           }
         }).catch(error => {
           console.log(error);
diff --git a/static/vrtest/vrHuman.FBX b/static/vrtest/vrHuman.FBX
index 7f7e2a04b..47a969a0a 100644
Binary files a/static/vrtest/vrHuman.FBX and b/static/vrtest/vrHuman.FBX differ