delete points from ways
[potlatch2.git] / net / systemeD / halcyon / connection / Way.as
1 package net.systemeD.halcyon.connection {
2     import flash.geom.Point;
3         import net.systemeD.halcyon.Globals;
4
5     public class Way extends Entity {
6         private var nodes:Array;
7                 public static var entity_type:String = 'way';
8
9         public function Way(id:Number, version:uint, tags:Object, loaded:Boolean, nodes:Array) {
10             super(id, version, tags, loaded);
11             this.nodes = nodes;
12                         for each (var node:Node in nodes) { node.addParent(this); }
13         }
14
15                 public function update(version:uint, tags:Object, loaded:Boolean, nodes:Array):void {
16                         var node:Node;
17                         for each (node in this.nodes) { node.removeParent(this); }
18                         updateEntityProperties(version,tags,loaded); this.nodes=nodes;
19                         for each (node in nodes) { node.addParent(this); }
20                 }
21                 
22         public function get length():uint {
23             return nodes.length;
24         }
25         
26         public function getNode(index:uint):Node {
27             return nodes[index];
28         }
29
30                 public function getLastNode():Node {
31                         return nodes[nodes.length-1];
32                 }
33
34         public function insertNode(index:uint, node:Node):void {
35                         node.addParent(this);
36             nodes.splice(index, 0, node);
37             markDirty();
38             dispatchEvent(new WayNodeEvent(Connection.WAY_NODE_ADDED, node, this, index));
39         }
40
41         public function appendNode(node:Node):uint {
42                         node.addParent(this);
43             nodes.push(node);
44             markDirty();
45             dispatchEvent(new WayNodeEvent(Connection.WAY_NODE_ADDED, node, this, nodes.length - 1));
46             return nodes.length;
47         }
48         
49         public function prependNode(node:Node):uint {
50                         node.addParent(this);
51             nodes.unshift(node);
52             markDirty();
53             dispatchEvent(new WayNodeEvent(Connection.WAY_NODE_ADDED, node, this, 0));
54             return nodes.length;
55         }
56         
57         public function indexOfNode(node:Node):uint {
58             return nodes.indexOf(node);
59         }
60
61                 public function removeNode(node:Node):void {
62                         var i:int;
63                         while ((i=nodes.indexOf(node))>-1) {
64                                 nodes.splice(i,1);
65                 dispatchEvent(new WayNodeEvent(Connection.WAY_NODE_REMOVED, node, this, i));
66                         }
67                         node.removeParent(this);
68                         markDirty();
69                 }
70
71         public function removeNodeByIndex(index:uint):void {
72             var removed:Array=nodes.splice(index, 1);
73                         if (nodes.indexOf(removed[0])==-1) { removed[0].removeParent(this); }
74                         markDirty();
75             dispatchEvent(new WayNodeEvent(Connection.WAY_NODE_REMOVED, removed[0], this, index));
76         }
77
78                 public function removeAllNodes():void {
79                         var node:Node;
80                         while (nodes.length) { 
81                                 node=nodes.pop();
82                                 dispatchEvent(new WayNodeEvent(Connection.WAY_NODE_REMOVED, node, this, 0));
83                                 // ** the event mechanism calls redraw once per wayNodeRemoved, which isn't too efficient
84                                 //    so we should probably add a 'redraw' flag to WayNodeEvent
85                                 node.removeParent(this);
86                         }
87                         // ** we should send an event to delete the entire way
88                 }
89
90                 public function sliceNodes(start:int,end:int):Array {
91                         return nodes.slice(start,end);
92                 }
93
94                 public function deleteNodesFrom(start:int):void {
95                         nodes.splice(start);
96                 }
97
98                 public function mergeWith(way:Way,topos:int,frompos:int):void {
99                         var i:int;
100
101                         // merge relations
102                         for each (var r:Relation in way.parentRelations) {
103                                 // ** needs to copy roles as well
104                                 if (r.findEntityMemberIndex(this)==-1) {
105                                         r.appendMember(new RelationMember(this, ''));
106                                 }
107                         }
108
109                         // merge tags
110                         var t:Object=way.getTagsHash();
111                         for (var k:String in t) {
112                                 if (getTag(k) && getTag(k)!=t[k]) {
113                                         setTag(k,getTag(k)+"; "+t[k]);
114                                         // ** send a warning about tags not matching
115                                 } else {
116                                         setTag(k,t[k]);
117                                 }
118                         }
119
120                         // merge nodes
121                         if (frompos==0) { for (i=0; i<way.length;    i++) { addToEnd(topos,way.getNode(i)); } }
122                                            else { for (i=way.length-1; i>=0; i--) { addToEnd(topos,way.getNode(i)); } }
123
124                         // delete way
125                         way.remove();
126                 }
127                 
128                 private function addToEnd(topos:int,node:Node):void {
129                         if (topos==0) {
130                                 if (nodes[0]==node) { return; }
131                                 prependNode(node);
132                         } else {
133                                 if (nodes[nodes.length-1]==node) { return; }
134                                 appendNode(node);
135                         }
136                 }
137
138
139
140         /**
141          * Finds the 1st way segment which intersects the projected
142          * coordinate and adds the node to that segment. If snap is
143          * specified then the node is moved to exactly bisect the
144          * segment.
145          */
146         public function insertNodeAtClosestPosition(newNode:Node, isSnap:Boolean):int {
147             var closestProportion:Number = 1;
148             var newIndex:uint = 0;
149             var nP:Point = new Point(newNode.lon, newNode.latp);
150             var snapped:Point = null;
151             
152             for ( var i:uint; i < length - 1; i++ ) {
153                 var node1:Node = getNode(i);
154                 var node2:Node = getNode(i+1);
155                 var p1:Point = new Point(node1.lon, node1.latp);
156                 var p2:Point = new Point(node2.lon, node2.latp);
157                 
158                 var directDist:Number = Point.distance(p1, p2);
159                 var viaNewDist:Number = Point.distance(p1, nP) + Point.distance(nP, p2);
160                         
161                 var proportion:Number = Math.abs(viaNewDist/directDist - 1);
162                 if ( proportion < closestProportion ) {
163                     newIndex = i+1;
164                     closestProportion = proportion;
165                     snapped = calculateSnappedPoint(p1, p2, nP);
166                 }
167             }
168             
169             // splice in new node
170             if ( isSnap ) {
171                 newNode.latp = snapped.y;
172                 newNode.lon = snapped.x;
173             }
174             insertNode(newIndex, newNode);
175             return newIndex;
176         }
177         
178         private function calculateSnappedPoint(p1:Point, p2:Point, nP:Point):Point {
179             var w:Number = p2.x - p1.x;
180             var h:Number = p2.y - p1.y;
181             var u:Number = ((nP.x-p1.x) * w + (nP.y-p1.y) * h) / (w*w + h*h);
182             return new Point(p1.x + u*w, p1.y+u*h);
183         }
184         
185         public override function toString():String {
186             return "Way("+id+"@"+version+"): "+getTagList()+
187                      " "+nodes.map(function(item:Node,index:int, arr:Array):String {return item.id.toString();}).join(",");
188         }
189
190                 public function isArea():Boolean {
191                         return (nodes[0].id==nodes[nodes.length-1].id && nodes.length>2);
192                 }
193                 
194                 public override function remove():void {
195                         removeFromParents();
196                         for each (var node:Node in nodes) {
197                                 node.removeParent(this);
198                                 if (!node.hasParentWays) { node.remove(); }
199                         }
200                         nodes=[];
201                         deleted=true;
202             dispatchEvent(new EntityEvent(Connection.WAY_DELETED, this));
203                 }
204
205                 internal override function isEmpty():Boolean {
206                         return (deleted || (nodes.length==0));
207                 }
208
209                 public override function getType():String {
210                         return 'way';
211                 }
212     }
213
214 }