Add route_sections for traces

4 files changed, 324 insertions, 0 deletions

diff --git a/app/maps/design/route_section_selector_style_map.rb b/app/maps/design/route_section_selector_style_map.rb
new file mode 100644
index 000000000..12f192ec8
--- /dev/null
+++ b/app/maps/design/route_section_selector_style_map.rb
@@ -0,0 +1,73 @@
+class Design::RouteSectionSelectorStyleMap < Design::GenericStyleMap
+  attr_accessor :style
+
+  def initialize(helpers, options = {})
+    @helpers = helpers
+    @style = options[:style].present? ? default_style.merge(options[:style]) : default_style
+  end
+
+  def select_style
+    {
+      fillColor: "blue",
+      graphicName: "square",
+      rotation: 90,
+      strokeColor: "#00dd00",
+      pointRadius: 15,
+      graphicZIndex: 100
+    }
+  end
+
+  def highlight_style
+    {
+      fillColor: "orange",
+      graphicName: "square",
+      rotation: 90,
+      strokeColor: "#dd0000",
+      pointRadius: 15,
+      graphicZIndex: 200
+    }
+  end
+
+  def default_style
+    {
+      label: "${label}",
+      fontColor: "black",
+      fontSize: "11px",
+      fontWeight: "bold",
+      labelAlign: "ct",
+      labelXOffset: 0,
+      labelYOffset: -15,
+      strokeColor: "#0000dd",
+      strokeOpacity: 1,
+      strokeWidth: 3,
+      strokeLineCap: "round",
+      strokeDashstyle: "solid",
+      externalGraphic: @helpers.assets_path_patch( "map/${positionType}.png"),
+      graphicWidth: 12,
+      graphicHeight: 12,
+      graphicOpacity: 1,
+      graphicXOffset: -6,
+      graphicYOffset: -6,
+      display: true,
+      fillColor: "red",
+      graphicName: "square",
+      rotation: 90,
+      graphicZIndex: 10
+    }
+  end
+
+  def context
+    {
+      label: :" function(feature) {if(feature.layer.map.getZoom() > 13) { return feature.attributes.name;} else {return '';}} ",
+      positionType: :" function(feature) { if (feature.attributes.iconCode != undefined) {return feature.attributes.iconCode;} else { return '';} } "
+    }
+  end
+
+  def style_map
+    OpenLayers::StyleMap.new(
+        default: OpenLayers::Style.new(style, { context: context}),
+        select: OpenLayers::Style.new(style.merge(select_style), { context: context }),
+        highlight: OpenLayers::Style.new(style.merge( highlight_style), { context: context }))
+  end
+
+end
diff --git a/app/maps/design/route_section_style_map.rb b/app/maps/design/route_section_style_map.rb
new file mode 100644
index 000000000..2c94bb3a0
--- /dev/null
+++ b/app/maps/design/route_section_style_map.rb
@@ -0,0 +1,66 @@
+class Design::RouteSectionStyleMap < Design::GenericStyleMap
+  attr_accessor :style
+
+  def initialize(helpers, options = {})
+    @helpers= helpers
+    @style = options[:style].present? ? default_style.merge(options[:style]) : default_style
+  end
+
+  def select_style
+    {
+      fillColor:"blue",
+      graphicName:"circle",
+      rotation:90,
+      :strokeColor => "red",
+      pointerEvents: "visiblePainted"
+    }
+  end
+
+  def highlight_style
+    {
+      fillColor:"lightblue",
+      graphicName:"circle",
+      rotation:90,
+      :strokeColor => "#dd0000"
+    }
+  end
+
+  def default_style
+
+    {
+      :fontColor => "black",
+      :fontSize => "11px",
+      :fontWeight => "bold",
+      :labelAlign => "cm",
+      :labelXOffset => 0,
+      :labelYOffset => -15,
+      :strokeColor => "green",
+      :strokeOpacity => 1,
+      :strokeWidth => 2,
+      :strokeLineCap => "round",
+      :strokeLineJoin => "round",
+      :strokeDashstyle => "solid",
+      :lineCap => "round",
+      :lineJoin => "round",
+      :dashstyle => "solid",
+      :graphicWidth => 12,
+      :graphicHeight => 12,
+      :graphicOpacity => 1,
+      :graphicXOffset => -6,
+      :graphicYOffset => -6,
+      :display => true,
+      fillOpacity: 0.5,
+      fillColor: "lightblue",
+      graphicName: "circle",
+      pointRadius: 6,
+      pointerEvents: "visiblePainted",
+      rotation: 90
+    }
+
+  end
+
+  def style_map
+    OpenLayers::StyleMap.new(:default => OpenLayers::Style.new(style), :select =>  OpenLayers::Style.new(style.merge( select_style)), :highlight =>  OpenLayers::Style.new(style.merge( highlight_style)))
+  end
+
+end
diff --git a/app/maps/route_section_map.rb b/app/maps/route_section_map.rb
new file mode 100644
index 000000000..cfa40d481
--- /dev/null
+++ b/app/maps/route_section_map.rb
@@ -0,0 +1,67 @@
+class RouteSectionMap < ApplicationMap
+
+  attr_reader :route_section
+
+  attr_accessor :editable
+  alias_method :editable?, :editable
+
+  def initialize(route_section, editable = false)
+    @route_section = route_section
+    @editable = editable
+  end
+
+  def customize_map(map, page)
+    # layers order seems to matter for ModifyFeature control
+    route_section.stop_areas.each do |stop_area|
+      layer = "stop_area_#{stop_area.id}".to_sym
+      page.assign layer.to_s, kml_layer(stop_area, :styleMap => Design::StopAreasStyleMap.new(helpers).style_map)
+      page << map.add_layer(layer)
+      page << map.add_control( hover_control_display_name(layer) )
+    end
+
+    geometry_options = {}.tap do |options|
+      options[:mode] = :editable if editable?
+    end
+    geometry_uneditable_kml_layer = kml_layer(route_section, :styleMap => Design::RouteSectionSelectorStyleMap.new(helpers).style_map)
+    page << map.add_layer(geometry_uneditable_kml_layer)
+
+    if route_section.input_geometry
+      geometry_editable_layer = kml_layer(route_section, geometry_options, {}) # , :styleMap => Design::LineStyleMap.new(style: nil).style_map)
+    else
+      points = route_section.stop_areas.map{|point| OpenLayers::Geometry::Point.new(point.longitude, point.latitude).transform("EPSG:4326", "EPSG:900913")}
+      geometry_editable_layer = OpenLayers::Layer::Vector.new("user_geometry", {:projection => projection("EPSG:4326"), :styleMap => Design::RouteSectionStyleMap.new(helpers).style_map})
+      #geometry_editable_layer = OpenLayers::Layer::Vector.new("user_geometry", {:projection => projection("EPSG:4326")})
+      geometry_editable_features = OpenLayers::Feature::Vector.new(OpenLayers::Geometry::LineString.new(points))
+      page.assign :geometry_editable_features, geometry_editable_features
+    end
+
+    if editable
+      page.assign :user_geometry, geometry_editable_layer
+
+      page << "user_geometry.addFeatures([geometry_editable_features])" if geometry_editable_features
+
+      page << map.add_layer(:user_geometry)
+
+      page.assign :modify_feature, OpenLayers::Control::ModifyFeature.new(:user_geometry, autoActivate: true)
+      page << map.add_control( :modify_feature )
+    else
+      page << map.add_layer(geometry_editable_layer)
+    end
+
+    page << map.zoom_to_extent(bounds.to_google.to_openlayers) if bounds
+  end
+
+  def bounds
+    @bounds ||=
+      if route_section.geometry.present?
+        route_section.geometry.bounds
+      elsif route_section.stop_areas.present?
+        GeoRuby::SimpleFeatures::Point.bounds route_section.stop_areas.collect(&:geometry)
+      end
+  end
+
+  def ready?
+    bounds.present?
+  end
+
+end
diff --git a/app/maps/route_section_selector_map.rb b/app/maps/route_section_selector_map.rb
new file mode 100644
index 000000000..425a6750a
--- /dev/null
+++ b/app/maps/route_section_selector_map.rb
@@ -0,0 +1,118 @@
+class RouteSectionSelectorMap < ApplicationMap
+
+  attr_reader :route_section_selector, :style
+
+  def initialize(route_section_selector, style = nil)
+    @route_section_selector = route_section_selector
+    @style = nil
+  end
+
+  def customize_map(map, page)
+    layer = kml_layer([route_section_selector.itinerary.referential, route_section_selector.itinerary.route.line, route_section_selector.itinerary.route, route_section_selector.itinerary],
+                      { rendererOptions: { zIndexing: true }, styleMap: Design::JourneyPatternStyleMap.new(helpers).style_map })
+    page.assign 'journeyPatternLayer', layer
+
+    page << map.add_layer(:journeyPatternLayer)
+    page << map.add_control(hover_control_display_name(:journeyPatternLayer))
+
+    route_section_geometry = OpenLayers::Layer::Vector.new('Route Section Geometry',
+                                                           { projection: projection('EPSG:900913'),
+                                                             rendererOptions: { zIndexing: true },
+                                                             styleMap: Design::RouteSectionSelectorStyleMap.new(helpers).style_map})
+
+    route_section_layer_points = []
+    route_section_selector.sections.reject{|s| s.candidates.length==0}.each do |section|
+      section.candidates.each do |candidate|
+        geometry = candidate.processed_geometry
+        route_section_layer_points << ["#{candidate.id}"] + clean_route_section_line(geometry)
+      end
+    end
+
+    page.assign :route_section_layer_points, route_section_layer_points
+    page << <<EOF
+      var route_section_layers;
+      route_section_layers = route_section_layer_points.map(function(elt, index) {
+        var route_section_id = elt[0];
+        elt.splice(0, 1);
+        var points = elt.map( function(e,i) {
+          return OpenLayers.Projection.transform(new OpenLayers.Geometry.Point(e[0], e[1]), "EPSG:4326", "EPSG:900913" );
+          })
+        return new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString(points), {id: route_section_id, name: ""});
+      })
+EOF
+    page.assign :route_section_geometry, route_section_geometry
+    page << 'route_section_geometry.addFeatures(route_section_layers)'
+    page << map.add_layer(:route_section_geometry)
+
+    page << <<EOF
+    function selected(feature) {
+      RouteSectionMap.onSelectedFeature(feature);
+    }
+    function unselected(feature) {
+      RouteSectionMap.onUnselectedFeature(feature);
+    }
+
+    highlightControl = new OpenLayers.Control.SelectFeature([route_section_geometry],
+      {
+        clickout: true,
+        toggle: false,
+        multiple:false,
+        hover:true,
+        highlightOnly:true,
+        eventListeners:{
+          featurehighlighted: function (event) {
+            event.feature.layer.drawFeature(
+              event.feature,
+              'highlight'
+            );
+          },
+          featureunhighlighted: function (event) {
+            event.feature.layer.drawFeature(
+              event.feature,
+                'default'
+            );
+          }
+        }
+      }
+    );
+    selectControl = new OpenLayers.Control.SelectFeature([route_section_geometry],
+      {
+        onSelect:selected,
+        onUnselect:unselected
+      }
+    );
+    map.addControl(highlightControl);
+    map.addControl(selectControl);
+    highlightControl.activate();
+    selectControl.activate();
+EOF
+
+    #page.assign :select_feature, OpenLayers::Control::SelectFeature.new(:route_section_geometry, {onSelect: selected, onUnselect: unselected})
+    #page << map.add_control( :select_feature )
+
+
+    page << map.zoom_to_extent(bounds.to_google.to_openlayers) if bounds
+
+  end
+
+  def clean_route_section_line(line)
+    point_array = line.to_s.scan(/\d+[.]\d+\s\d+[.]\d+/)
+    proj = OpenLayers::Projection.new('proj')
+
+    point_array.map do |point|
+      point = point.scan(/\d+[.]\d+/)
+      lat = point[0].to_f
+      lng = point[1].to_f
+      [lat, lng]
+    end
+
+  end
+
+  def ready?
+     bounds.present?
+   end
+
+   def bounds
+     @bounds ||= GeoRuby::SimpleFeatures::Point.bounds(route_section_selector.itinerary.route.stop_areas.collect(&:geometry).compact)
+   end
+end