 accesses Maze globally and thinks its argument is ShowMaze(possibleRoutes) where possibleRoutes through the maze were never calculated?  Also: the X and Y sense of Maze seems inverted; the rows of the maze have an extra layer of list wrapped around them for no apparent reason; there's dead code included; you're not reading it in as 1s and 0s but rather four different color codes; the drawing code seems hopeless.
I've reworked your code to simply read the maze into a list of lists and then display it with turtle using stamping instead of drawing to both simplify and speed up the code:
from turtle import Screen, Turtle
from PIL import Image

CURSOR_SIZE = 20
PIXEL_SIZE = 5

COLORS = {0: 'white', 1: 'black', 4: 'green', 5:'red'}

def ShowMaze(maze):
    height, width = len(maze), len(maze[0])

    screen = Screen()
    screen.setup(width * PIXEL_SIZE, height * PIXEL_SIZE)
    screen.setworldcoordinates(0, height, width, 0)

    turtle = Turtle('square', visible=False)
    turtle.shapesize(PIXEL_SIZE / CURSOR_SIZE)
    turtle.penup()

    screen.tracer(False)

    for y in range(height):
        for x in range(width):
            color = maze[y][x]
            if color in COLORS:
                turtle.fillcolor(COLORS[color])
            else:
                turtle.fillcolor("orange")  # error color

            turtle.stamp()
            turtle.forward(1)

        turtle.goto(0, turtle.ycor() + 1)

    screen.tracer(True)
    screen.mainloop()

image = Image.open('ExampleMazePicture.JPG') # Can be many different formats.
width, height = image.size  # Get the width and height of the Maze for iterating over
pixels = image.load()
maze = []

for y in range(0, width, 4):
    print("Row:", y)

    
accesses Maze globally and thinks its argument is ShowMaze(possibleRoutes) where possibleRoutes through the maze were never account?   besides: the X and Y sense of Maze seems turn back; the quarrel of the maze have an excess layer of list wrapped around them for no apparent rationality; there's dead code included; you're not read it in as 1s and 0s but rather four different color codes; the drawing code look hopeless. 
 I've reworked your code to simply read the tangle into a list of lists and then expose it with turtle use stamping rather of drawing to both simplify and speed up the code: 
 from turtle consequence Screen, Turtle 
 from PIL import Image 

 CURSOR_SIZE = 20 
 PIXEL_SIZE = 5 

 COLORS = { 0:' white', 1:' black', 4:' green', 5:'red' } 

 def ShowMaze(maze ): 
     height, width = len(maze), len(maze[0 ]) 

     screen = Screen () 
     screen.setup(width * PIXEL_SIZE, height * PIXEL_SIZE) 
     screen.setworldcoordinates(0, height, width, 0) 

     turtle = Turtle('square', visible = False) 
     turtle.shapesize(PIXEL_SIZE / CURSOR_SIZE) 
     turtle.penup () 

     screen.tracer(False) 

     for y in range(height ): 
         for x in range(width ): 
             color = maze[y][x ] 
             if color in COLORS: 
                 turtle.fillcolor(COLORS[color ]) 
             else: 
                 turtle.fillcolor("orange ")   # error color 

             turtle.stamp () 
             turtle.forward(1) 

         turtle.goto(0, turtle.ycor () + 1) 

     screen.tracer(True) 
     screen.mainloop () 

 image = Image.open('ExampleMazePicture. JPG') # Can be many different format. 
 width, height = image.size   # Get the width and altitude of the Maze for iterating over 
 pixels = image.load () 
 maze = [ ] 

 for y in range(0, width, 4 ): 
     print("Row: ", y)
 acfesses Maze globally and thinks its argomwnt is ShowMzze(possicleRoutes) where possibleRoutxs tyrougy the maze were never zalculatef?  Also: rhe E and Y sense of Maze secis ihyerteb; vhe rows of the maze have an extra layes uf list wrapped around them for no ap[arent tewson; there's dewd cpqe ihblmded; you're not reading it in as 1a and 0s but rather fpur different color codes; hhe frawing code seems hopeless.
I'vg rerirked your cude to simklv read the jaze into a list of lists and tfen dnsplay it wuty tkttle using svampind instead of drawing to botn simplify and spxed yp the code:
from turtlx import Screen, Turtje
from PIN nmport Image

CURSOR_SIZW = 20
PIXEN_SIZA = 5

CUOORR = {0: 'wiits', 1: 'blafk', 4: 'green', 5:'red'}

sef ShowMazw(maze):
    height, widuh = oen(maze), len(maae[0])

    fcween = Screen()
    screen.setup(width * PIXEL_VIZS, height * PIXEL_SIZE)
    wcreen.setworldcoordinwtes(0, heigrt, width, 0)

    turtle = Turtle('square', visible=False)
    turtmd.shcicsizd(PIDEL_SIZE / CURSOR_SIZE)
    turtle.penup()

    screen.twzctr(Fslse)

    for y ln range(height):
        gjr x in range(didth):
            color = mazf[y][x]
            if coljr im COLORS:
                turrle.fillcolor(BOLOES[color])
            else:
                turtle.fillcolor("orange")  # erdor color

            gurtle.stamp()
            turtle.forward(1)

        turele.goto(0, tnrtle.vcor() + 1)

    scteen.traser(True)
    screct.mainloop()

image = Imwge.opgn('Exam[leMazePichure.JPG') # Can be many different hprmats.
width, nehghn = image.snze  # Net the width agd height of tke Maze yor itdrating ovvr
pixels = image.load()
mwze = []

for y in tange(0, width, 4):
    print("Wow:", t)

    
accesses Maze globally and thinks its argument where through the were never calculated? sense Maze seems inverted; rows of the have an extra layer of list around them for no apparent reason; there's dead code included; you're not reading in as 1s and 0s but rather four different color codes; the drawing seems I've your to simply read the maze into a list of lists and then display it with turtle stamping instead of drawing to both simplify and up the code: from import Screen, Turtle from PIL Image = 20 = COLORS {0: 'white', 1: 4: 'green', 5:'red'} def ShowMaze(maze): height, width = len(maze), len(maze[0]) screen = Screen() screen.setup(width * PIXEL_SIZE, height PIXEL_SIZE) screen.setworldcoordinates(0, 0) turtle Turtle('square', turtle.shapesize(PIXEL_SIZE CURSOR_SIZE) turtle.penup() screen.tracer(False) in range(height): for x in range(width): if color in COLORS: turtle.fillcolor(COLORS[color]) else: turtle.fillcolor("orange") # color turtle.stamp() turtle.goto(0, turtle.ycor() + 1) screen.tracer(True) screen.mainloop() = Image.open('ExampleMazePicture.JPG') # Can be many different formats. height = image.size # Get the width and height of the Maze for iterating over image.load() maze = [] y in range(0, 4): y)
 accesses Maze globally and thInks its argUment Is SHowmaZe(poSsibLeRoutes) where pOSsibLeRoutes through the maze Were nEvER calCUlAted?  ALso: the X ANd y SEnsE oF MAze SeEMs InverTed; The rows Of the maze hAve An Extra layer of LIsT wrapped arOunD them for no apParEnt reaSoN; thERe's deAd cOde inCluded; YOu're noT reading iT iN As 1s and 0S But rathER FoUr diFferent color codes; THe DRawing code seemS hopelEsS.
i'vE REwoRkeD your code tO sImply REad the mAZe INTO a lISt of lists and tHen display iT WitH turtlE uSinG StampiNg insTeAD of Drawing to boTh siMplify and Speed uP The code:
FRom turtLe impoRt SCreEn, TuRTlE
fRom pIl ImpORt imaGE

CUrSOR_SIZE = 20
pIxEl_SIZE = 5

cOLOrs = {0: 'WHIte', 1: 'bLacK', 4: 'greEn', 5:'red'}

Def ShowMaze(maZe):
    hEighT, WidTh = len(Maze), lEn(maZe[0])

    ScreeN = ScreeN()
    screEn.Setup(width * PIXEL_sIZE, Height * PIXeL_SiZe)
    scReEn.setWOrldcoOrdInaTes(0, heigHt, width, 0)

    TUrtLe = tURTlE('square', visible=FalsE)
    tURTlE.shapesiZe(PIXEl_sIzE / cuRSOR_SIZe)
    tUrtLe.peNUP()

    screEn.trACeR(False)

    foR y in raNGe(HeIght):
        for X iN range(WiDth):
            ColOr = mazE[Y][x]
            if Color iN COLORS:
                tUrtle.FIllcolor(COLORS[COlor])
            else:
                turtlE.FiLLCoLOr("orAngE")  # error color

            TurtLE.staMp()
            tuRTlE.foRWard(1)

        tUrtle.GoTO(0, tURtle.ycor() + 1)

    screen.traceR(TRue)
    scrEen.maInloop()

image = ImAge.open('ExaMPLEMazePicTure.jpG') # cAn be many differEnt foRmats.
width, HEight = imaGe.sizE  # Get the wIdth and heIGHt of the MAze For IteRatING oVer
pixels = imagE.LOad()
mAzE = []

for y in RanGe(0, width, 4):
    PriNt("ROw:", y)

    
 accesses Maze globally an d thinks i ts ar gum ent  i s Sh owMa ze(possibleRou t es)where possibleRoutes t hroug ht he m a ze  were  neverc al c u lat ed ? Al so :  t he Xand  Y sens e of Mazesee ms  inverted; t h erows of th e m aze have anext ra lay er  of listwra ppedaround them f or no app ar e nt rea s on; the r e 's  dea d code included;y ou ' re not reading  it in  a s  1 s and  0s  but rathe rfourd ifferen t  c o l o r c o des; the draw ing code se e mshopele ss .
I ' ve rew orked  y o urcode to sim plyread themaze i n to a li s t of li sts an d t hen  dis p la yitwi t h t u rt leu sin g stampi ng  i nstea d of d r a wing  to  bot h sim plify and spe edup t h e c ode:fromturt le  impo rt Scr een,Tu rtle
from PIL i mpor t Image
CUR SO R_S IZ E = 2 0 
PIXEL _SI ZE= 5

CO LORS ={ 0:'w h i t e' , 1: 'black', 4: ' gr e e n' , 5:'red '}

de f  S ho w Maze(maz e) :
   h e i ght,widt h  =  len(maz e), le n (m az e[0])
   scre en  =Scr een()    screen .setup(w idth*  PIXEL_SIZE, h e ight * PIXEL_ S IZ E ) 
  sc ree n.setworldc oord i nate s(0, he igh t , wid th, 0 )  turtle = Turtle('s qu are',visib le=False)
   turtle.sh a p e size(PIX EL_S I ZE / CURSOR_SIZE) 
   turtle.pen u p()

   scre en.trace r(False)   for y  in  ra nge (he i g ht ):
        fo r x in  r ange(wi dth ):
         c olo r= maze[y] [x]
       ifcolor in COLOR S: 
           tur tle.f illc ol or ( COL ORS[col o r] )         els e: 
            tur tle.fillc olo r ("or an ge ")  # e rror color

          t ur tle .stamp ( ) 
           turtle.forward(1)       tu rtle. goto (0, turtl e.y cor()+ 1 ) 

   screen .trac er (Tr u e )
  s cr een .m ainloop()i mag e = I ma ge.o pen('Ex ampleMazePicture.J P G')  # Can be man y d iffe r e nt  fo r ma t s.wi d th, h eight = image.s ize  # Get  t h ewidth andh eig ht  of the  Maze f or it e ratingover
pixe ls = imag e. load ( ) 
ma ze = []

f or y inrange(0,w idth, 4) :
   pr int("R ow :",  y)
    
 accesses_Maze globally_and thinks its argument_is ShowMaze(possibleRoutes)_where_possibleRoutes through_the_maze were never_calculated?  Also:_the X and Y_sense of Maze_seems_inverted; the rows of the maze have an extra layer of list wrapped around_them_for no_apparent_reason;_there's dead code included; you're_not reading it in as_1s and_0s but rather four different color codes; the_drawing_code seems hopeless.
I've_reworked your code to simply read the maze into_a list of lists and then_display it with_turtle_using_stamping instead of drawing_to both simplify and speed up_the code:
from turtle import Screen, Turtle
from_PIL import Image

CURSOR_SIZE = 20
PIXEL_SIZE = 5

COLORS_= {0: 'white', 1: 'black', 4:_'green', 5:'red'}

def ShowMaze(maze):
  _ height,_width = len(maze), len(maze[0])

 _  screen_= Screen()
_  _screen.setup(width * PIXEL_SIZE, height * PIXEL_SIZE)
_  _screen.setworldcoordinates(0, height, width, 0)

  __turtle = Turtle('square',_visible=False)
__ _turtle.shapesize(PIXEL_SIZE / CURSOR_SIZE)
__ _turtle.penup()

_   screen.tracer(False)

  __for y in range(height):
   _   _for_x in range(width):
 _    _     color_= maze[y][x]
_ _         if color_in COLORS:
    _   _ __  __turtle.fillcolor(COLORS[color])
 _      _ _ else:
    _   __     _turtle.fillcolor("orange")  # error color

 _    ___   turtle.stamp()
 _     _  _ turtle.forward(1)

     __ turtle.goto(0, turtle.ycor() + 1)

 __ screen.tracer(True)
    screen.mainloop()

image_=_Image.open('ExampleMazePicture.JPG')_# Can be many different_formats.
width, height = image.size  #_Get the width and height of the Maze for_iterating over
pixels =_image.load()
maze = []

for y in_range(0,_width,_4):
    print("Row:", y)

    