[Question]
  [
Today is November 11th, which for many regions is [Remembrance Day](https://en.wikipedia.org/wiki/Remembrance_Day).
If you don't know anything about the history or context of Remembrance Day, you can read about it in the wiki page, but it's not relevant for this challenge.
*In Flanders Fields* is a poem that is pretty well-known relating to this day. It opens like so:
```
In Flanders fields the poppies blow
Between the crosses, row on row
```
# Challenge
You will be given a grid with crosses (represented below as `+`) on it. Your task is to grow poppies between all crosses. That is, fill the space between any two crosses that are on the same row or column with poppies (represented below as `*`).
# Example
```
....+....
...+.+...
.........
....+....
..+...+..
.........
..+...+..
```
This becomes:
```
....+....
...+*+...
....*....
....+....
..+***+..
..*...*..
..+***+..
```
Rigorously defined, on a non-cylindrical grid, each grid space is `+` if it was `+`, and becomes `*` if it has a `+` in the same column above and below it, or in the same row to its left and right.
# Test Cases
```
.....+...    .....+...
+......+.    +******+.
....+.+.. -> *...+*+..
+.+...+..    +*+***+..
...++.+..    ...++*+..
.+.....    .+.....
....+..    .*..+..
...+..+    .*.+**+
.+++...    .+++*.*
....... -> .****.*
.+++.+.    .+++*+*
.++.++.    .++*++*
.......    .*....*
.+....+    .+****+
.......    .......
...+...    ...+...
.....++    .....++
++.....    ++...**
+....+. -> +****+*
.....+.    .....+*
.......    ......*
.......    ......*
..+...+    ..+***+
.+.+..    .+*+..
.....+    .*.*.+
+.....    +*.*.*
.+....    .+.*.*
...+.+ -> ...+*+
......    ......
......    ......
....+.    ....+.
```
# Rules and Specifications
Input requires a grid of two distinct values. You can take this in any convenient format, and you can choose to use any reasonable convenient values, like `0` and `1`, for example.
Output requires a grid of three distinct values. Again, you can deliver this in any reasonable, convenient format.
Standard loopholes apply.
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge, so the shortest solution in each language wins. No answer will be accepted.
(Sorry for posting another challenge, especially another [ascii-art](/questions/tagged/ascii-art "show questions tagged 'ascii-art'") one, so soon, but I really wanted to do something for 11/11 and I thought of it after my pattern expansion one)
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~131~~ 125 bytes
```
f=lambda A,p=1:map(''.join,zip(*[re.sub('\+.+\+',lambda x:re.sub('\.','*',x.group()),s)for s in p and f(A,0)or A]))
import re
```
[Try it online!](https://tio.run/##ZY8xDoMwDEXncgqLxQmJrLYjEkPOAQwgoE1VkiiARHt5Sgp0qeXB/78vy3av8W7NdVm67Fn1dVOBki67pH3lGCI9rDbyrR1Lct/SMNUMC0GiECj3@Jz@AKHEBOVMN28nxziXA@@shwG0AQeVaaBjSp756qmS80j3zvoRfLuEmAqxPEciERpLGWb6ynU1oKBdBrFN4iBiy@1EbKQs0@jkvDYjxNla8aGwMNtvTPHd@0frrfxHlw8 "Python 2 – Try It Online")
Input is a list of strings; as is output.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ẒT.ịr/Ṭ»)Z$⁺
```
A monadic Link accepting a list of lists where:
* crosses, `+`, are `2`
* spaces, `.`, are `0`
which yields a list of lists as above with poppies, `*`, as `1`.
**[Try it online!](https://tio.run/##y0rNyan8///hrkkheg93dxfpP9y55tBuzSiVR427/v//Hx1toKNgpKNggIxidRSikQWMsAjD9RhBhY1gCIchqMLIqo3QhREMgoagODM2FgA "Jelly – Try It Online")** Or see [one which translates IO](https://tio.run/##y0rNyan8///hrkkheg93dxfpP9y55tBuzSiVR427/j/cvcX2UcNc7cPTjQ63A2UfNczR0tYDikT@/6@nrQcCXCBCG0IDKW0uPW1tbZg4mAbxtcE0CCGJg3UCAA).
### How?
```
ẒT.ịr/Ṭ»)Z$⁺ - Link: list of lists
          $  - last two links as a monad  - i.e. f(Rows):
        )    -   for each Row in Rows:
Ẓ            -     is prime? (vectorises) (isCross() that work's once poppies are planted)
 T           -     truthy indices e.g. [0,0,1,0,0,1,1,0] -> [3,6,7]
  .          -     literal one half
   ị         -     index into (the truthy indices)  -- non-integer indices reference the 
             -         items on either side of that location & indexing is 1-based and
             -         modular, so [last,first]  e.g. [3,6,7]->[7,3] or [8] -> [8,8]
     /       -     reduce by:
    r        -       inclusive range  e.g. [7,3]->[7,6,5,4,3] or [8,8]->[8]
      Ṭ      -     un-truth  e.g. [7,6,5,4,3]->[0,0,1,1,1,1,1] or [8]->[0,0,0,0,0,0,0,1]
       »     -     maximum (with Row) (vectorises) (keep crosses, plant poppies)
         Z   -   transpose
           ⁺ - repeat the last link (plant the remaining column poppies and transpose back)
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 96 bytes
```
param($a)$a=&($g={($a=$a-replace'(?<=\+.*)\.(?=.*\+)','*')[0]|% t*y|%{-join$a.chars($i++)}});&$g
```
[Try it online!](https://tio.run/##rZXRboJAEEXf@YoNrgIzuOl7S/SpP1GbZgOr0iBQwLQG/XYLrNYWBksbNwbleGdyZ8aRNHlXWb5WUXTkS688pjKTG5tLh0tvYvOVV1Y3HpfTTKWR9JVlzx68BQpwFsKeeQIW6FiuBZbzdPe8H7MCdvtxOX1NwphL4a9llts8RHQOB@d@wlfHg2HMbYNVx9Vv9ZlfPlqiOlhfLPcHxIa2oD5tSISjxgPCz8ov5riD7AFlD4baA4COPdAJaOXFnnG50i3Vkdiu9bsfAlcUOxgRe5JQuFYjhevX4CSNxZ5xXC0N6NKg7iFZGgjoqqtD4FqNFAYkcPMzINR1cvz7KEXfKHuHg516kW6a7nZPksEz68P46yhvVhp02q27DXQSGovhGP83SuzZPmL58Mp@kA1D2vxwiuL62gG9XkB4rymxACRt/kxv6v00DIft2ZiVzR1fRjIOqmffY6iiIHcZVx@p8gsVMI/xF63JVL6NigpM@LId0SjMk8Sc@urN/EphNl@OzvFstI39ZLNRccGKdZizKIwVKxIWhHn1VN0xrcuNw/ET "PowerShell – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 44 bytes
```
'.*+'{~[:(+:+-.*](+.|:)&(>./\.*>./\)|:)=&'+'
```
[Try it online!](https://tio.run/##XU49C8IwFNzzKx4OTdKzz@KYUhEEJyfXWhykpbg42E3xr8d8CamP5OXeHXd5d7tiOVJrSNKaajLuVkyH8@loJZeQr09nFAwqLnsFfhtdqB1vLlz6rt3cFhLSajEPz7ll6gwNt@mxVz01NGrqG75uRVB9fi3YFXwTASChWAsVES/UH6f/EmMOOOGUg8BlOUBy53Ysvo5rMRyPfLk4I7z@ZHxwCm2/ "J – Try It Online")
No regex used:
* Takes the product of the max scan of the prefixes and the max scan of the suffixes to turn the in-between cells to 1.
* Does this for both the input and its transpose (to get both directions)
* "Or"s these two matrices.
* Multiplies by one minus the input, to get rid of endpoints (ie, original crosses)
* Add double the original matrix to that.
* After all this, in-between points in both directions are 1, original points are 2, rest are 0.
* We use that to index into `'.*+`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~18~~ 14 bytes
```
UÄUaÄa2
ZÇZoÇ_
```
[Try it online!](https://tio.run/##y0rNyan8/z/0cEto4uGWRCOuqMPtUfmH2@P/P9yxyfZRw1ztw@0Pd3c/apijraUH5Ea6cR1uf9S0JutR4z4urv//lfSAQBtEKIAZ2lAWBCggy2pD2CiyUDElHbA5EN3aelA2VLc2WAxJt7Y2TI82ii0QF@hpKwBVILsDwtcG0yCEJA7WCbMdbgJUhba2gjbUBm0kF@khm4DqE4ib4J7UVtBGtggaQgooeqGOVwIA "Jelly – Try It Online")
-4 bytes because I figured out what I did wrong with my cumulative sums 
Input and output is as two-dimensional lists with `.` mapped to 0, `+` mapped to 1, and `*` mapped to 2. (The footer on TIO converts automatically for convenience.)
```
           Helper link:
     a2    Fill in 2s wherever
    Ä      there's at least one truthy value to the left
UÄUa       and at least one truthy value to the right.
           This fills in poppies between (and on) all crosses horizontally.
   oÇ      Overlay the horizontal poppies
ZÇZ        on the vertical poppies,
     _     and subtract the crosses out to recover them.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-h`](https://codegolf.meta.stackexchange.com/a/14339/), 16 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
2Æ=Õ®Ëd0E©nFÊÉ}S
```
No regex!
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWg&code=MsY91a7LZDBFqW5Gysl9Uw&input=WyIwMDAwIDAwMDAiLCIwMDAgMCAwMDAiLCIwMDAwMDAwMDAiLCIwMDAwIDAwMDAiLCIwMCAwMDAgMDAiLCIwMDAwMDAwMDAiLCIwMCAwMDAgMDAiXQotUg)
```
2Æ=Õ®Ëd0E©nFÊÉ}S     U = input
2Æ                   2 times do:
  =                    Set U to
   Õ                     U transposed
    ®                    Map each row:
     Ë        }S           Split each row on spaces (crosses), 
                           and pass each chunk through the following function, 
                           then rejoin on spaces
                           For each chunk:
      d0                     Replace all 0's (empty spaces)             
        E©nFÊÉ               And replace with 1 if this chunk wasn't the first or last chunk
-h                   Take final result of second iteration
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 101 bytes
```
->s{g=->x{x.map(&:chars).transpose.map(&:join).map{|l|l[w=/\+.+\+/]&&l[w]=l[w].tr(?.,?*);l}};g[g[s]]}
```
[Try it online!](https://tio.run/##NYvBDoMgDIbvewpPIqvifQZ9EOTAlsm2OCWgmQvy7AyCa9Lm//q1er1@/UB91RoradVudiNvoYr8cnsIbTBZtJiMms39WL/m54Rjtvu4j@xD6x4I9FDzPA/IaRzhq@hI2Z1xMzrXSCaZ4dx5tS4mGxhDJBaERmWGgBwYISX4G0h3h4FkOD/5Hw "Ruby – Try It Online")
Not really satisfied with it, but it's a starting point.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 80 bytes
```
+`#( *)#
#$.1$**#
+ms`^(((.))*#.*^(?<-2>.)*(?(2)$)) (.*^(?<-3>.)*(?(3)$)#)
$1*$4
```
[Try it online!](https://tio.run/##TYwxDsIwDEV3nyKSPdj@qqW2jKi9ROcqDAwMMAD3D0koEpblp/8k/@f1fXtcypYDOXFBZk1uTCwxijsT7q@8q2qYOYfvup6HaQlzXXUyMUt62Pmwc7VsJKPLqRYnrt0lEG2oHXxZAQoAP9/ZMjrb/vn@@QE "Retina 0.8.2 – Try It Online") Includes header/footer that translates input/output between `.` and `+` to something more regex-friendly for the actual code. Explanation:
```
+`#( *)#
#$.1$**#
```
Repeatedly horizontally fill all s between `#`s. (Since this requires an unbroken run of s, this has to repeat until completion before the second stage runs.)
```
+ms`
```
Repeat as many times as necessary, allow `^` to match after a newline, and allow `.` to match newlines.
```
^(((.))*#.*
```
Look for a `#` and capture its indent twice.
```
^(?<-2>.)*(?(2)$)) (.*
```
Look for a  at the same indent.
```
^(?<-3>.)*(?(3)$)#)
```
Look for another `#` at the same indent.
```
$1*$4
```
Replace the  with a `*`.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) v2.0a0 [`-h`](https://codegolf.meta.stackexchange.com/a/14339/), ~~22~~ ~~21~~ ~~19~~ 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Uses `<space>` for `+`, `*` for `.` & `1` for `*`.
```
2Æ=Õr/ .+ /È×
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&flags=LWg&header=ci9cLi8nKiByL1wrL1M&code=MsY91XIvIC4rIC/I1w&footer=Vq5yKicuIHJTJysgcjEnKg&input=Ii4uLi4uKy4uLgorLi4uLi4uKy4KLi4uLisuKy4uCisuKy4uLisuLgouLi4rKy4rLi4i) (Header & footer convert I/O to characters used in spec)
```
2Æ=Õr/ .+ /È×     :Implicit input of string U
2Æ                :Map the range [0,2)
  =               :Reassign to U
   Õ              :Transpose U
    r/ .+ /       :Global RegEx replacement
           È      :Pass each match through a function
            ×     :  Replace all * with 1
                  :Implicit output of last element in array
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 85 bytes
```
a=>(g=m=>m[0].map((_,i)=>m.map(l=>l.join``.replace(/(?<=x.*)-(?=.*x)/g,8)[i])))(g(a))
```
[Try it online!](https://tio.run/##dVJLb5wwEL77V/hSYXsW016qqArk1ENPOfQY0q61ZQkRLy0k2n@/nRkbw@ZhIZj55vXNZ57dq5sOp2ac0374V12OMr@4vFB13uVF9/D10XZuVOrvrtHos9PmRWufh6bf7@2pGlt3qFSm7m7zszU6VXe5NWed1bsb/dA8aq1VrZzWl7maZplLJ/NCOjuNbTOrrOzLHjJtj8Pppzs8qYmiQsrD0E9DW9l2qBW6Uia/@vFl/lH2XyaquX@Zty69kx0nTshxxk7Zn/I3ZF2tmapKMEH7jKOa7HxqOqUDC4751Wh8u25VWtwjSTG6QkDQmQt4Dm2Os4zGXNx228dP3lafqRi2SEqI3SI3hJhEv2eOTCitcrP69l0jpIUWgoRVe2HxAL0EGxAsf66i4O2r6ILhsUsujYyOABtsgsHwgaUxBmVaSEOOAc4OHX02cLKnBgvMjlmm@v6MwxVnhkykjB8IEHYFLIRIFk1jzbIYMbJEkyDguTELGKInQAZgLQwTLRcyDZ/FO0eNNgpFanGxKD/AqiMIWNdk0xgvLDBbP8CIjdLeNO8nfgJBZMt0IWi76Agm3vyiIuooNqwIWNYOtxE0xS4sKd@xeDv8Y2BdAv@Vvb78Bw "JavaScript (Node.js) – Try It Online")
Input / Output as character matrix. Use `x` for `+`, `-` for `.`, `8` for `*`.
First, convert dots `.` between two crosses `+` in a row into star `*`.
```
l.join``.replace(/(?<=\+.*)\.(?=.*\+)/g,'*')
```
Then. rotate the matrix
```
a=>m=>m[0].map((_,i)=>m.map(l=>l[i]))
```
Repeat twice, and get the result.
[Answer]
# [Red](http://www.red-lang.org), ~~160~~ 154 bytes
```
func[b][loop 2[t: collect[until[parse keep rejoin
collect[forall b[keep take b/1]][any[thru"+"change
copy p to"+"(replace/all p".""*")]]empty? b/1]]b: t]]
```
[Try it online!](https://tio.run/##lVK7bsQgEOz9FSuqJCv5lJRu8g9pVxSYW8fOEUAcLvz1jp/oTJLCyEKzD3aYwYGv4wdfSRZNNTa91VRLMs55eKNYgXbGsI7U29gZ8ircGW7MHgJ/uc4We71xQRkDNS3FqG4M9eVVSlJ2oNiGXqDQrbKfPB3xA0w9bko9BfZGab7Mh70ohXgRz1Lyt4/D@zqhriBKOU4ErHQLprMMDVAhymnhvIkF4xKseF0i78E1@tWz50EC@dDZuLBI2HBTFH@z74xYblFixC1/YEQ8z4KZkl1riTNCPGrec7ih@cuqy5zzSh@Y00Sc74DphnjwoMyZc7/P@vDwcJg8T5LSP5CocoD/Oz/@AA "Red – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) (`-p`), 80 bytes
```
/
/;$l="."x"@-";1while s/(\+\S*)\.(\S*\+)|(\+$l(.$l)*)\.($l(.$l)*\+)/$1$3*$2$5/s
```
[Try it online!](https://tio.run/##VY7BCsIwDIbveQopPWz7WbopOw3Bd/Da68BBccMJevDZrV3TaS0tf/olf5J5uLnOe0Om1@6oWD3VqVZ9@7iMbtgtprCw56q0XASxKF8BaFewdmWkWxxSRrf6UOm97sziPa8H4RE4xSSCyCDplUEYsVSmMkmFGziw8aiIDopG5Dw66QfSBjIfhDQA2T6cN/gqUiNsi6xf5GOkOejPmlZ/T/N9nK6Lr5tm/gA "Perl 5 – Try It Online")
[Answer]
# [Python 3.8](https://docs.python.org/3.8/), 354 bytes
```
e,r=enumerate,range
def f(s):
	s=s.split('\n')
	t=[(x,y) for y,i in e(s) for x,c in e(i) if c=='+']
	#t is the '+'es coordinates
	m=sum((l for x,y in t for u,v in t 
		if (x==u)!=(y==v)and x<=u and y<=v and
		(l:=[[(y,j)for j in r(x+1,u)],[(i,x)for i in r(y+1,v)]][x==u]) and
		#l is coordinates of cells between two '+'es
		all(s[i][j]=='.' for i,j in l)),[])
	return '\n'.join(''.join([c,'*'][(y,x) in m]for x,c in e(i))for y,i in e(s))
```
[Try it online!](https://tio.run/##bVLLjtswDDxHX6Ge9KBWaNAeimC1P6LVwU3sVoatGH4E9tenlKzYabBEkFCjITlDpVvGv9fw41fX3@@l6k0ZprbsixHzIvwpyaWsaMUHcSKHwQx66Bo/cvYZmCCH0Vg@q0XQ6trTRXnqAy2Rm86zOq9nL6iv6NkYBsyRQ2uGqeW8yaQlksZ0mNRtPSCdz8ZM4pvhizE3UYQLnd/NRGOyvJtbTHhzMtbyRdUiVtextuczHNUknLLcqzld@PViwYubcM7Gzk6kVkXT8MF6Z2uH8jRLMrxKrRohlHXosi/HqQ80etb11QfO8q89KyaZixJmEUta92JcvCxG3Lveh5HHuRXeG1M/j2yLjjdF@/tS0OE0Tl1T8n2qf@yeMoF66Wbtv0dZd5@62e/q7eiEIj1jjGjQMShGTkn8ggzJlJIVgQyBlICFAFshgNQyFUbo7QNZGBGKLNhZkKD4yZAE2AvzRJ0Kk4yVFZsBwXgm6k0t7BA8DGDrjQVAYLeZUinJOiCpXQdkHbC3f5Gms7SvINjUJrmrWtj2iD43Ydkm7pE8qYrAw3Z@jbxT7JJWGjsDeR3@NbCbAI3PbI8n9/R3kD8Fxv0f "Python 3.8 (pre-release) – Try It Online") (without comments or unnecessary white-space)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 19 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
yV=_gZa0 oZb0)_p
yV
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=eVY9X2daYTAgb1piMClfcAp5Vg&footer=Vm1fbUBYKzEgZyIgK1x1MjVjYiI&input=WwogWy0xLC0xLDAsMCwtMSwtMV0sCiBbLTEsMCwwLC0xLDAsMF0sCiBbLTEsMCwwLC0xLDAsLTFdLAogWy0xLC0xLC0xLC0xLC0xLC0xXSwKIFswLC0xLDAsLTEsMCwtMV0KXQ)
```
U = U.y // for each columns
(V = function(Z) { return 
  Z.g // modify 
(Z.a(0).o(Z.b(0)), // indexes from first cross to Last cross
function(Z) { return Z.p() // power of 2: -1 => 1
 })  });
V = U.y(V); // repeat transposing
Outputs a matrix of values:
-1 -> ground,  1 -> poppies,  0 -> cross
Footer maps to [' ','○','+']
```
With the help of @Shaggy and @Embodiment of Ignorance
]