rgeo-dschee 0.5.4

data/lib/rgeo/geographic/proj4_projector.rb

@@ -0,0 +1,58 @@
+# -----------------------------------------------------------------------------
+#
+# Proj4 projection
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geographic
+    class Proj4Projector # :nodoc:
+      def initialize(geography_factory_, projection_factory_)
+        @geography_factory = geography_factory_
+        @projection_factory = projection_factory_
+      end
+
+      def _set_factories(geography_factory_, projection_factory_) # :nodoc:
+        @geography_factory = geography_factory_
+        @projection_factory = projection_factory_
+      end
+
+      def project(geometry_)
+        Feature.cast(geometry_, @projection_factory, :project)
+      end
+
+      def unproject(geometry_)
+        Feature.cast(geometry_, @geography_factory, :project)
+      end
+
+      attr_reader :projection_factory
+
+      def wraps?
+        false
+      end
+
+      def limits_window
+        nil
+      end
+
+      class << self
+        def create_from_existing_factory(geography_factory_, projection_factory_)
+          new(geography_factory_, projection_factory_)
+        end
+
+        def create_from_proj4(geography_factory_, proj4_, opts_ = {})
+          projection_factory_ = Cartesian.preferred_factory(proj4: proj4_,
+                                                            coord_sys: opts_[:coord_sys], srid: opts_[:srid],
+                                                            buffer_resolution: opts_[:buffer_resolution],
+                                                            lenient_multi_polygon_assertions: opts_[:lenient_multi_polygon_assertions],
+                                                            uses_lenient_assertions: opts_[:uses_lenient_assertions],
+                                                            has_z_coordinate: opts_[:has_z_coordinate],
+                                                            has_m_coordinate: opts_[:has_m_coordinate],
+                                                            wkt_parser: opts_[:wkt_parser], wkt_generator: opts_[:wkt_generator],
+                                                            wkb_parser: opts_[:wkb_parser], wkb_generator: opts_[:wkb_generator])
+          new(geography_factory_, projection_factory_)
+        end
+      end
+    end
+  end
+end

data/lib/rgeo/geographic/projected_feature_classes.rb

@@ -0,0 +1,107 @@
+# -----------------------------------------------------------------------------
+#
+# Projtected geographic feature classes
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geographic
+    class ProjectedPointImpl # :nodoc:
+      include Feature::Point
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicPointMethods
+      include ProjectedGeometryMethods
+      include ProjectedPointMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
+    end
+
+    class ProjectedLineStringImpl  # :nodoc:
+      include Feature::LineString
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include ProjectedGeometryMethods
+      include ProjectedNCurveMethods
+      include ProjectedLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
+    end
+
+    class ProjectedLinearRingImpl  # :nodoc:
+      include Feature::LinearRing
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include ImplHelper::BasicLinearRingMethods
+      include ProjectedGeometryMethods
+      include ProjectedNCurveMethods
+      include ProjectedLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
+    end
+
+    class ProjectedLineImpl # :nodoc:
+      include Feature::Line
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include ImplHelper::BasicLineMethods
+      include ProjectedGeometryMethods
+      include ProjectedNCurveMethods
+      include ProjectedLineStringMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
+    end
+
+    class ProjectedPolygonImpl # :nodoc:
+      include Feature::Polygon
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicPolygonMethods
+      include ProjectedGeometryMethods
+      include ProjectedNSurfaceMethods
+      include ProjectedPolygonMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
+    end
+
+    class ProjectedGeometryCollectionImpl # :nodoc:
+      include Feature::GeometryCollection
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ProjectedGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
+    end
+
+    class ProjectedMultiPointImpl # :nodoc:
+      include Feature::MultiPoint
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiPointMethods
+      include ProjectedGeometryMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
+    end
+
+    class ProjectedMultiLineStringImpl # :nodoc:
+      include Feature::MultiLineString
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiLineStringMethods
+      include ProjectedGeometryMethods
+      include ProjectedNCurveMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
+    end
+
+    class ProjectedMultiPolygonImpl # :nodoc:
+      include Feature::MultiPolygon
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiPolygonMethods
+      include ProjectedGeometryMethods
+      include ProjectedNSurfaceMethods
+      include ProjectedMultiPolygonMethods
+
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
+    end
+  end
+end

data/lib/rgeo/geographic/projected_feature_methods.rb

@@ -0,0 +1,212 @@
+# -----------------------------------------------------------------------------
+#
+# Projected geographic common method definitions
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geographic
+    module ProjectedGeometryMethods # :nodoc:
+      def srid
+        factory.srid
+      end
+
+      def projection
+        @projection = factory.project(self) unless defined?(@projection)
+        @projection
+      end
+
+      def envelope
+        factory.unproject(projection.envelope)
+      end
+
+      def is_empty?
+        projection.is_empty?
+      end
+
+      def is_simple?
+        projection.is_simple?
+      end
+
+      def boundary
+        boundary_ = projection.boundary
+        boundary_ ? factory.unproject(boundary_) : nil
+      end
+
+      def equals?(rhs_)
+        projection.equals?(Feature.cast(rhs_, factory).projection)
+      end
+
+      def disjoint?(rhs_)
+        projection.disjoint?(Feature.cast(rhs_, factory).projection)
+      end
+
+      def intersects?(rhs_)
+        projection.intersects?(Feature.cast(rhs_, factory).projection)
+      end
+
+      def touches?(rhs_)
+        projection.touches?(Feature.cast(rhs_, factory).projection)
+      end
+
+      def crosses?(rhs_)
+        projection.crosses?(Feature.cast(rhs_, factory).projection)
+      end
+
+      def within?(rhs_)
+        projection.within?(Feature.cast(rhs_, factory).projection)
+      end
+
+      def contains?(rhs_)
+        projection.contains?(Feature.cast(rhs_, factory).projection)
+      end
+
+      def overlaps?(rhs_)
+        projection.overlaps?(Feature.cast(rhs_, factory).projection)
+      end
+
+      def relate(rhs_, pattern_)
+        projection.relate(Feature.cast(rhs_, factory).projection, pattern_)
+      end
+
+      def distance(rhs_)
+        projection.distance(Feature.cast(rhs_, factory).projection)
+      end
+
+      def buffer(distance_)
+        factory.unproject(projection.buffer(distance_))
+      end
+
+      def buffer_with_style(distance_, endCapStyle_, joinStyle_, mitreLimit_)
+        factory.unproject(projection.buffer_with_style(distance_, endCapStyle_, joinStyle_, mitreLimit_))
+      end
+
+      def simplify(tolerance_)
+        factory.unproject(projection.simplify(tolerance_))
+      end
+
+      def simplify_preserve_topology(tolerance_)
+        factory.unproject(projection.simplify_preserve_topology(tolerance_))
+      end
+
+      def convex_hull
+        factory.unproject(projection.convex_hull)
+      end
+
+      def intersection(rhs_)
+        factory.unproject(projection.intersection(Feature.cast(rhs_, factory).projection))
+      end
+
+      def union(rhs_)
+        factory.unproject(projection.union(Feature.cast(rhs_, factory).projection))
+      end
+
+      def difference(rhs_)
+        factory.unproject(projection.difference(Feature.cast(rhs_, factory).projection))
+      end
+
+      def sym_difference(rhs_)
+        factory.unproject(projection.sym_difference(Feature.cast(rhs_, factory).projection))
+      end
+    end
+
+    module ProjectedPointMethods # :nodoc:
+      def _validate_geometry
+        @y = 85.0511287 if @y > 85.0511287
+        @y = -85.0511287 if @y < -85.0511287
+        super
+      end
+
+      def canonical_x
+        x_ = @x % 360.0
+        x_ -= 360.0 if x_ > 180.0
+        x_
+      end
+      alias_method :canonical_longitude, :canonical_x
+      alias_method :canonical_lon, :canonical_x
+
+      def canonical_point
+        if @x >= -180.0 && @x < 180.0
+          self
+        else
+          PointImpl.new(@factory, canonical_x, @y)
+        end
+      end
+
+      def self.included(klass_)
+        klass_.module_eval do
+          alias_method :longitude, :x
+          alias_method :lon, :x
+          alias_method :latitude, :y
+          alias_method :lat, :y
+        end
+      end
+    end
+
+    module ProjectedNCurveMethods # :nodoc:
+      def length
+        projection.length
+      end
+    end
+
+    module ProjectedLineStringMethods # :nodoc:
+      def _validate_geometry
+        size_ = @points.size
+        if size_ > 1
+          last_ = @points[0]
+          (1...size_).each do |i_|
+            p_ = @points[i_]
+            last_x_ = last_.x
+            p_x_ = p_.x
+            changed_ = true
+            if p_x_ < last_x_ - 180.0
+              p_x_ += 360.0 while p_x_ < last_x_ - 180.0
+            elsif p_x_ > last_x_ + 180.0
+              p_x_ -= 360.0 while p_x_ > last_x_ + 180.0
+            else
+              changed_ = false
+            end
+            if changed_
+              p_ = factory.point(p_x_, p_.y)
+              @points[i_] = p_
+            end
+            last_ = p_
+          end
+        end
+        super
+      end
+    end
+
+    module ProjectedNSurfaceMethods # :nodoc:
+      def area
+        projection.area
+      end
+
+      def centroid
+        factory.unproject(projection.centroid)
+      end
+
+      def point_on_surface
+        factory.unproject(projection.point_on_surface)
+      end
+    end
+
+    module ProjectedPolygonMethods # :nodoc:
+      def _validate_geometry
+        super
+        unless projection
+          raise Error::InvalidGeometry, "Polygon failed assertions"
+        end
+      end
+    end
+
+    module ProjectedMultiPolygonMethods # :nodoc:
+      def _validate_geometry
+        super
+        unless projection
+          raise Error::InvalidGeometry, "MultiPolygon failed assertions"
+        end
+      end
+    end
+  end
+end

data/lib/rgeo/geographic/projected_window.rb

@@ -0,0 +1,383 @@
+# -----------------------------------------------------------------------------
+#
+# A projected window in a geography implementation
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geographic
+    # This object represents an axis-aligned rectangle in a map projection
+    # coordinate system. It is commonly used to specify the viewport for a
+    # map visualization, an envelope in a projected coordinate system, or
+    # a spatial constraint. It must be attached to a Geographic::Factory
+    # that has a projection.
+
+    class ProjectedWindow
+      # Create a new ProjectedWindow given the Geographic::Factory, and the
+      # x and y extents of the rectangle.
+      #
+      # The window will be intelligently clamped to the limits imposed by
+      # the factory. For example, the simple mercator factory limits
+      # latitude to approximately +/-85 degrees.
+      #
+      # Generally, you will not need to call this low-level constructor
+      # directly. Instead, use one of the provided class methods.
+
+      def initialize(factory_, x_min_, y_min_, x_max_, y_max_, opts_ = {})
+        @factory = factory_
+        limits_ = opts_[:is_limits] ? nil : factory_.projection_limits_window
+        wraps_ = factory_.projection_wraps?
+        y_max_, y_min_ = y_min_, y_max_ if y_max_ < y_min_
+        x_max_, x_min_ = x_min_, x_max_ if x_max_ < x_min_ && !wraps_
+        if limits_
+          y_max_ = limits_.y_max if y_max_ > limits_.y_max
+          y_min_ = limits_.y_min if y_min_ < limits_.y_min
+          if wraps_
+            width_ = limits_.x_span
+            if x_max_ - x_min_ > width_
+              center_ = (x_max_ + x_min_) * 0.5
+              x_min_ = center_ - width_ * 0.499999999
+              x_max_ = center_ + width_ * 0.499999999
+            end
+            x_max_ = x_max_ % width_
+            x_max_ -= width_ if x_max_ >= limits_.x_max
+            x_min_ = x_min_ % width_
+            x_min_ -= width_ if x_min_ >= limits_.x_max
+          else
+            x_max_ = limits_.x_max if x_max_ > limits_.x_max
+            x_min_ = limits_.x_min if x_min_ < limits_.x_min
+          end
+        end
+        @x_min = x_min_
+        @y_min = y_min_
+        @x_max = x_max_
+        @y_max = y_max_
+      end
+
+      def to_s # :nodoc:
+        "#<#{self.class}:0x#{object_id.to_s(16)} s=#{@y_min} w=#{@x_min} n=#{@y_max} e=#{@x_max}>"
+      end
+
+      def inspect # :nodoc:
+        to_s
+      end
+
+      def eql?(obj_) # :nodoc:
+        return false unless obj_.is_a?(ProjectedWindow)
+        @factory == obj_.factory && @x_min == obj_.x_min && @x_max == obj_.x_max &&
+          @y_min = obj_.y_min && @y_max = obj_.y_max
+      end
+      alias_method :==, :eql?
+
+      def hash # :nodoc:
+        @factory.hash + @x_min.hash + @x_max.hash + @y_min.hash + @y_max.hash
+      end
+
+      # Returns the Geographic::Factory associated with this window.
+      # Note that this factory is the overall geography factory, not the
+      # projected factory (which can be obtained by calling
+      # Geographic::Factory#projection_factory on this factory).
+
+      attr_reader :factory
+
+      # Returns the lower limit in the x (easting) direction.
+
+      attr_reader :x_min
+
+      # Returns the upper limit in the x (easting) direction.
+
+      attr_reader :x_max
+
+      # Returns the lower limit in the y (northing) direction.
+
+      attr_reader :y_min
+
+      # Returns the upper limit in the y (northing) direction.
+
+      attr_reader :y_max
+
+      # Returns true if the projection wraps along the x axis, and this
+      # rectangle crosses that seam.
+
+      def crosses_seam?
+        @x_max < @x_min
+      end
+
+      # Returns true if the rectangle has zero area.
+
+      def degenerate?
+        @x_min == @x_max || @y_min == @y_max
+      end
+
+      # Returns the width of the rectangle.
+
+      def x_span
+        span_ = @x_max - @x_min
+        span_ += @factory.projection_limits_window.x_span if span_ < 0
+        span_
+      end
+      alias_method :width, :x_span
+
+      # Returns the height of the rectangle.
+
+      def y_span
+        @y_max - @y_min
+      end
+      alias_method :height, :y_span
+
+      # Returns a two-element array containing the x and y coordinates
+      # of the center of the rectangle.
+
+      def center_xy
+        y_ = (@y_min + @y_max) * 0.5
+        if @x_min > @x_max
+          x_ = @x_min + x_span * 0.5
+          limits_ = @factory.projection_limits_window
+          x_ -= limits_.x_span if x_ >= limits_.x_max
+        else
+          x_ = (@x_min + @x_max) * 0.5
+        end
+        [x_, y_]
+      end
+
+      # Returns the southwest corner of the rectangle in _unprojected_
+      # (lat/lng) space, as a Feature::Point object.
+
+      def sw_point
+        @sw ||= @factory.unproject(@factory.projection_factory.point(@x_min, @y_min))
+      end
+
+      # Returns the southeast corner of the rectangle in _unprojected_
+      # (lat/lng) space, as a Feature::Point object.
+
+      def se_point
+        @se ||= @factory.unproject(@factory.projection_factory.point(@x_max, @y_min))
+      end
+
+      # Returns the northwest corner of the rectangle in _unprojected_
+      # (lat/lng) space, as a Feature::Point object.
+
+      def nw_point
+        @nw ||= @factory.unproject(@factory.projection_factory.point(@x_min, @y_max))
+      end
+
+      # Returns the northeast corner of the rectangle in _unprojected_
+      # (lat/lng) space, as a Feature::Point object.
+
+      def ne_point
+        @ne ||= @factory.unproject(@factory.projection_factory.point(@x_max, @y_max))
+      end
+
+      # Returns the center of the rectangle in _unprojected_
+      # (lat/lng) space, as a Feature::Point object.
+
+      def center_point
+        @center ||= @factory.unproject(@factory.projection_factory.point(*center_xy))
+      end
+
+      # Returns a random point inside the rectangle in _unprojected_
+      # (lat/lng) space, as a Feature::Point object.
+
+      def random_point
+        y_ = @y_min + y_span * rand
+        x_ = @x_min + x_span * rand
+        limits_ = @factory.projection_limits_window
+        x_ -= limits_.x_span if x_ >= limits_.x_max
+        @factory.unproject(@factory.projection_factory.point(x_, y_))
+      end
+
+      # Returns true if the rectangle contains the given point, which
+      # must be a Feature::Point in _unprojected_ (lat/lng) space.
+
+      def contains_point?(point_)
+        projection_ = @factory.project(point_)
+        y_ = projection_.y
+        if y_ <= @y_max && y_ >= @y_min
+          x_ = projection_.x
+          limits_ = @factory.projection_limits_window
+          width_ = limits_.x_span
+          x_ = x_ % width_
+          x_ -= width_ if x_ >= limits_.x_max
+          if @x_max < @x_min
+            x_ <= @x_max || x_ >= @x_min
+          else
+            x_ <= @x_max && x_ >= @x_min
+          end
+        else
+          false
+        end
+      end
+
+      # Returns true if the given window is completely contained within
+      # this window.
+
+      def contains_window?(window_)
+        return nil if window_.factory != @factory
+        if window_.y_max <= @y_max && window_.y_min >= @y_min
+          if (@x_max < @x_min) == window_.crosses_seam?
+            window_.x_max <= @x_max && window_.x_min >= @x_min
+          else
+            @x_max < @x_min && (window_.x_max <= @x_max || window_.x_min >= @x_min)
+          end
+        else
+          false
+        end
+      end
+
+      # Returns a new window resulting from scaling this window by the
+      # given factors, which must be floating-point values.
+      # If y_factor is not explicitly given, it defaults to the same as
+      # the x_factor.
+
+      def scaled_by(x_factor_, y_factor_ = nil)
+        y_factor_ ||= x_factor_
+        if x_factor_ != 1.0 || y_factor_ != 1.0
+          x_, y_ = *center_xy
+          xr_ = x_span * 0.5 * x_factor_
+          yr_ = y_span * 0.5 * y_factor_
+          ProjectedWindow.new(@factory, x_ - xr_, y_ - yr_, x_ + xr_, y_ + yr_)
+        else
+          self
+        end
+      end
+      alias_method :*, :scaled_by
+
+      # Returns a new window resulting from clamping this window to the
+      # given minimum and maximum widths and heights, in the projected
+      # coordinate system. The center of the resulting window is the
+      # same as the center of this window. Any of the arguments may be
+      # given as nil, indicating no constraint.
+
+      def clamped_by(min_width_, min_height_, max_width_, max_height_)
+        xr_ = x_span
+        yr_ = y_span
+        changed_ = false
+        if min_width_ && xr_ < min_width_
+          changed_ = true
+          xr_ = min_width_
+        end
+        if max_width_ && xr_ > max_width_
+          changed_ = true
+          xr_ = max_width_
+        end
+        if min_height_ && yr_ < min_height_
+          changed_ = true
+          yr_ = min_height_
+        end
+        if max_height_ && yr_ > max_height_
+          changed_ = true
+          yr_ = max_height_
+        end
+        if changed_
+          x_, y_ = *center_xy
+          xr_ *= 0.5
+          yr_ *= 0.5
+          ProjectedWindow.new(@factory, x_ - xr_, y_ - yr_, x_ + xr_, y_ + yr_)
+        else
+          self
+        end
+      end
+
+      # Returns a new window resulting from adding the given margin to
+      # this window. If y_margin is not given, it defaults to the same
+      # value as x_margin. Note that the margins may be negative to
+      # indicate shrinking of the window.
+
+      def with_margin(x_margin_, y_margin_ = nil)
+        y_margin_ ||= x_margin_
+        if x_margin_ != 0.0 || y_margin_ != 0.0
+          ProjectedWindow.new(@factory, @x_min - x_margin_, @y_min - y_margin_,
+            @x_max + x_margin_, @y_max + y_margin_)
+        else
+          self
+        end
+      end
+
+      class << self
+        # Creates a new window whose coordinates are the given points,
+        # which must be Feature::Point objects in unprojected (lat/lng)
+        # space.
+
+        def for_corners(sw_, ne_)
+          factory_ = sw_.factory
+          psw_ = factory_.project(sw_)
+          pne_ = factory_.project(ne_)
+          ProjectedWindow.new(factory_, psw_.x, psw_.y, pne_.x, pne_.y)
+        end
+
+        # Creates a new window that surrounds the given point with the
+        # given margin. The point must be a Feature::Point object in
+        # unprojected (lat/lng) space, while the margins are numbers in
+        # projected space. The y_margin may be given as nil, in which
+        # case it is set to the same as the x_margin.
+
+        def surrounding_point(point_, x_margin_ = nil, y_margin_ = nil)
+          x_margin_ ||= 0.0
+          y_margin_ ||= x_margin_
+          factory_ = point_.factory
+          projection_ = factory_.project(point_)
+          ProjectedWindow.new(factory_, projection_.x - x_margin_, projection_.y - y_margin_,
+            projection_.x + x_margin_, projection_.y + y_margin_)
+        end
+
+        # Creates a new window that contains all of the given points.
+        # which must be Feature::Point objects in unprojected (lat/lng)
+        # space.
+
+        def bounding_points(points_)
+          factory_ = nil
+          limits_ = nil
+          width_ = nil
+          x_max_ = nil
+          x_min_ = nil
+          y_max_ = nil
+          y_min_ = nil
+          x_array_ = nil
+          points_.each do |p_|
+            unless factory_
+              factory_ = p_.factory
+              limits_ = factory_.projection_limits_window
+              width_ = limits_.x_span
+              x_array_ = [] if factory_.projection_wraps?
+            end
+            proj_ = factory_.project(p_)
+            x_ = proj_.x
+            if x_array_
+              x_ = x_ % width_
+              x_ -= width_ if x_ >= limits_.x_max
+              x_array_ << x_
+            else
+              x_max_ = x_ if !x_max_ || x_max_ < x_
+              x_min_ = x_ if !x_min_ || x_min_ > x_
+            end
+            y_ = proj_.y
+            y_max_ = y_ if !y_max_ || y_max_ < y_
+            y_min_ = y_ if !y_min_ || y_min_ > y_
+          end
+          return nil unless factory_
+          if x_array_
+            x_array_.sort!
+            largest_span_ = nil
+            last_ = x_array_.last
+            x_array_.each do |x_|
+              if largest_span_
+                span_ = x_ - last_
+                if span_ > largest_span_
+                  largest_span_ = span_
+                  x_min_ = x_
+                  x_max_ = last_
+                end
+              else
+                largest_span_ = x_ - last_ + width_
+                x_min_ = x_
+                x_max_ = last_
+              end
+              last_ = x_
+            end
+          end
+          ProjectedWindow.new(factory_, x_min_, y_min_, x_max_, y_max_)
+        end
+      end
+    end
+  end
+end