#194 HSysProjectionEarth now providing straits for GridWorldGui.

Tiling/src/egrid/GridWorldGui.scala

@@ -74,18 +74,10 @@ class GridWorldGui(val canv: CanvasPlatform, scenIn: EScenWarm, viewIn: HGView)
 //    def sides3: Arr[(HSide, LineSegM3)] = sides2.filter((sc, ls) => ls.zsPos)
 //    def sides4: Arr[(HSide, LineSeg)] = sides3.map{ (sc, ls) => (sc, ls.map(_.xy / scale)) }
 
-    val sides0 = sTerrs.truesMap(_.lineSegHC.map(gridSys.hCoordLL(_)))
-    def sides1: LineSegM3Arr = sides0.map{ _.map(_.toMetres3) }
-    def sides2: LineSegM3Arr = sides1.map{ _.map(_.fromLatLongFocus(focus)) }
-    def sides3: LineSegM3Arr = sides2.filter(_.zsPos)
-    def sides4: LineSegArr = sides3.map{ _.map(_.xy / scale) }
-    def sides: GraphicElems = sides4.map{ ls  => Rectangle.fromAxisRatio(ls, 0.3).fill(Red) }
-
-    val outers = gridSys.outerSideLineM3s
-    val outers2 = outers.fromLatLongFocus(focus)
-    val outers3 = outers2.filter(_.zsPos)
-    val outers4 = outers3.map(_.xyLineSeg(scale).draw(Gold, 3))
-    def outers5 = Arr(proj.outerSidesDraw(3, Gold))//  ifGScale(4, outers4)
+    def straits: LineSegArr =  proj.transHSides(sTerrs.trueHSides)
+    def straitsDraw: GraphicElems = straits.map{ ls  => Rectangle.fromAxisRatio(ls, 0.3).fill(Red) }
+
+    def outerLines = proj.outerSidesDraw(3, Gold)//  ifGScale(4, outers4)
 
     val irrLines = irr1.map { a => a._2.map(_ / scale).draw(White) }
     def irrLines2 = ifGScale(2, irrLines)
@@ -99,7 +91,7 @@ class GridWorldGui(val canv: CanvasPlatform, scenIn: EScenWarm, viewIn: HGView)
 
     def seas: EllipseFill = earth2DEllipse(scale).fill(LightBlue)
 
-    mainRepaint(seas %: irrFills ++ irrNames2 ++ hexs2 ++ lines6 ++ outers5 ++ rcTexts ++ irrLines2 ++ sides)
+    mainRepaint(seas %: irrFills ++ irrNames2 ++ hexs2 ++ lines6 +% outerLines ++ rcTexts ++ irrLines2 ++ straitsDraw)
   }
   def thisTop(): Unit = reTop(Arr(zoomIn, zoomOut, goNorth, goSouth, goWest, goEast))
   thisTop()

Tiling/src/egrid/HSysProjectionEarth.scala

@@ -35,13 +35,19 @@ case class HSysProjectionEarth(gridSys: EGridSys, panel: Panel) extends HSysProj
 
   //def sides: GraphicElems = sides4.map { ls => Rectangle.fromAxisRatio(ls, 0.3).fill(Red) }
 
-  override def sides: LineSegArr = ???
+  override def sides: LineSegArr = transLineSegM3Arr(gridSys.sideLineM3s)
+  override def innerSides: LineSegArr = transLineSegM3Arr(gridSys.innerSideLineM3s)
+  def outerSides: LineSegArr = transLineSegM3Arr(gridSys.outerSideLineM3s)
 
-  override def innerSides: LineSegArr = ???
+  def transHSides(inp: HSideArr): LineSegArr = {
+    val lls: LineSegLLArr = inp.map(_.lineSegHC.map(gridSys.hCoordLL(_)))
+    val m3s = lls.map(_.map(_.toMetres3))
+    transLineSegM3Arr(m3s)
+  }
 
-  val outers = gridSys.outerSideLineM3s
-  def outers2 = outers.fromLatLongFocus(focus)
-  def outers3 = outers2.filter(_.zsPos)
-  def outerSides: LineSegArr = outers3.map(_.xyLineSeg(scale))//.draw(Colour.Gold, 3)
-  //override def outerSides: LineSegArr = ???
+  def transLineSegM3Arr(inp: LineSegM3Arr): LineSegArr ={
+    val rotated = inp.fromLatLongFocus(focus)
+    val visible = rotated.filter(_.zsPos)
+    visible.map(_.xyLineSeg(scale))
+  }
 }

Tiling/src/prid/phex/HSideDGrid.scala

@@ -38,6 +38,8 @@ final class HSideBoolDGrid(val unsafeArray: Array[Boolean]) extends AnyVal with
     build.buffToBB(buff)
   }
 
+  def trueHSides(implicit gridSys: HGridSys): HSideArr = truesMap(hs => hs)
+
   def set(hs: HSide, value: Boolean)(implicit grid: HGridSys): Unit = {
     val i = grid.sideArrIndex(hs)
     if (i >= unsafeArray.length) deb(s"$hs")

Tiling/src/prid/phex/HSysProjection.scala

@@ -6,12 +6,28 @@ import geom._, pgui._
 trait HSysProjection
 { type GridT <: HGridSys
   def gridSys: GridT
+
+  /** The visible hex sides. */
   def sides: LineSegArr
+
+  /** The visible inner hex sides. */
   def innerSides: LineSegArr
+
+  /** The visible outer hex sides. */
   def outerSides: LineSegArr
+
+  /** transforms and filters out non visible [[HSide]]s. */
+  def transHSides(inp: HSideArr): LineSegArr
+
+  /** Draws visible hex sides. */
   def sidesDraw(lineWidth: Double = 2, colour: Colour = Colour.Black): LinesDraw = sides.draw(lineWidth, colour)
+
+  /** Draws visible inner hex sides. */
   def innerSidesDraw(lineWidth: Double = 2, colour: Colour = Colour.Black): LinesDraw = innerSides.draw(lineWidth, colour)
+
+  /** Draws visible outer hex sides. */
   def outerSidesDraw(lineWidth: Double = 2, colour: Colour = Colour.Black): LinesDraw = outerSides.draw(lineWidth, colour)
+
   def panel: Panel
   def setView(view: Any): Unit = {}
 }

Tiling/src/prid/phex/HSysProjectionFlat.scala

@@ -11,6 +11,8 @@ final case class HSysProjectionFlat(gridSys: HGridSys, panel: Panel) extends HSy
   override def innerSides: LineSegArr = gridSys.innerSideLines.slate(-focus).scale(cPScale)
   override def outerSides: LineSegArr = gridSys.outerSideLines.slate(-focus).scale(cPScale)
 
+  override def transHSides(inp: HSideArr): LineSegArr = ???//.slate(-focus).scale(cPScale)
+
   override def setView(view: Any): Unit = view match
   {
     case hv: HGView => {