Ë
    {�h—8  ã                   óœ   — d dl Z d dlmZmZ d dlmZ d dlmZ  ej                  d«      Z	d„ Z
de j                  dz  d	fd
„Z G d„ de«      Zy)é    N)Ú
exceptionsÚoptional_imports)Úutils)Ú
graph_objsÚnumpyc                 ób  — t         du rt        d«      ‚t        t        | «      dz
  «      D ]4  }| |dz      | |   z
  | d   | d   z
  z
  dkD  sŒ!t	        j
                  d«      ‚ t        t        |«      dz
  «      D ]4  }||dz      ||   z
  |d   |d   z
  z
  dkD  sŒ!t	        j
                  d«      ‚ y)	as  
    Streamline-specific validations

    Specifically, this checks that x and y are both evenly spaced,
    and that the package numpy is available.

    See FigureFactory.create_streamline() for params

    :raises: (ImportError) If numpy is not available.
    :raises: (PlotlyError) If x is not evenly spaced.
    :raises: (PlotlyError) If y is not evenly spaced.
    Fz.FigureFactory.create_streamline requires numpyé   r   g-Cëâ6?z.x must be a 1 dimensional, evenly spaced arrayz.y must be a 1 dimensional, evenly spaced arrayN)ÚnpÚImportErrorÚrangeÚlenr   ÚPlotlyError)ÚxÚyÚindexs      ú_/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/plotly/figure_factory/_streamline.pyÚvalidate_streamliner   
   sÑ   € ô 
ˆU�{ÜÐJÓKÐKÜ”s˜1“v ‘zÓ"ò ˆØˆu�q‰y‰\˜A˜e™HÑ$¨¨1©°°!±©Ñ5¸Ó?Ü×(Ñ(ØCóð ðô
 ”s˜1“v ‘zÓ"ò ˆØˆu�q‰y‰\˜A˜e™HÑ$¨¨1©°°!±©Ñ5¸Ó?Ü×(Ñ(ØCóð ñó    r	   é	   g
×£p=
·?c           	      óÆ  — t        j                  | |«       t        j                  ||«       t        | |«       t        j                  ||¬«       t	        | ||||||«      j                  «       \  }}	t	        | ||||||«      j                  «       \  }
}t        j                  d||
z   |	|z   ddœ|¤Ž}|g}t        j                  d¬«      }t        j                  ||¬«      S )aa	  
    Returns data for a streamline plot.

    :param (list|ndarray) x: 1 dimensional, evenly spaced list or array
    :param (list|ndarray) y: 1 dimensional, evenly spaced list or array
    :param (ndarray) u: 2 dimensional array
    :param (ndarray) v: 2 dimensional array
    :param (float|int) density: controls the density of streamlines in
        plot. This is multiplied by 30 to scale similiarly to other
        available streamline functions such as matplotlib.
        Default = 1
    :param (angle in radians) angle: angle of arrowhead. Default = pi/9
    :param (float in [0,1]) arrow_scale: value to scale length of arrowhead
        Default = .09
    :param kwargs: kwargs passed through plotly.graph_objs.Scatter
        for more information on valid kwargs call
        help(plotly.graph_objs.Scatter)

    :rtype (dict): returns a representation of streamline figure.

    Example 1: Plot simple streamline and increase arrow size

    >>> from plotly.figure_factory import create_streamline
    >>> import plotly.graph_objects as go
    >>> import numpy as np
    >>> import math

    >>> # Add data
    >>> x = np.linspace(-3, 3, 100)
    >>> y = np.linspace(-3, 3, 100)
    >>> Y, X = np.meshgrid(x, y)
    >>> u = -1 - X**2 + Y
    >>> v = 1 + X - Y**2
    >>> u = u.T  # Transpose
    >>> v = v.T  # Transpose

    >>> # Create streamline
    >>> fig = create_streamline(x, y, u, v, arrow_scale=.1)
    >>> fig.show()

    Example 2: from nbviewer.ipython.org/github/barbagroup/AeroPython

    >>> from plotly.figure_factory import create_streamline
    >>> import numpy as np
    >>> import math

    >>> # Add data
    >>> N = 50
    >>> x_start, x_end = -2.0, 2.0
    >>> y_start, y_end = -1.0, 1.0
    >>> x = np.linspace(x_start, x_end, N)
    >>> y = np.linspace(y_start, y_end, N)
    >>> X, Y = np.meshgrid(x, y)
    >>> ss = 5.0
    >>> x_s, y_s = -1.0, 0.0

    >>> # Compute the velocity field on the mesh grid
    >>> u_s = ss/(2*np.pi) * (X-x_s)/((X-x_s)**2 + (Y-y_s)**2)
    >>> v_s = ss/(2*np.pi) * (Y-y_s)/((X-x_s)**2 + (Y-y_s)**2)

    >>> # Create streamline
    >>> fig = create_streamline(x, y, u_s, v_s, density=2, name='streamline')

    >>> # Add source point
    >>> point = go.Scatter(x=[x_s], y=[y_s], mode='markers',
    ...                    marker_size=14, name='source point')

    >>> fig.add_trace(point) # doctest: +SKIP
    >>> fig.show()
    )ÚdensityÚarrow_scaleÚlines)r   r   ÚmodeÚclosest)Ú	hovermode)ÚdataÚlayout© )r   Úvalidate_equal_lengthr   Úvalidate_positive_scalarsÚ_StreamlineÚsum_streamlinesÚget_streamline_arrowsr   ÚScatterÚLayoutÚFigure)r   r   ÚuÚvr   Úangler   ÚkwargsÚstreamline_xÚstreamline_yÚarrow_xÚarrow_yÚ
streamliner   r   s                  r   Úcreate_streamliner1   %   sî   € ôR 
×Ñ  1Ô%Ü	×Ñ  1Ô%Ü˜˜1ÔÜ	×#Ñ#¨GÀÕMä!,Ø	ˆ1ˆa��G˜U Kó"ç�oÓñ €L�,ô #Ø	ˆ1ˆa��G˜U KóçÑÓñ €GˆWô ×#Ñ#ð Ø
˜Ñ
  L°7Ñ$:ÀñØLRñ€Jð ˆ<€DÜ×Ñ¨Ô3€Fä×Ñ $¨vÔ6Ð6r   c                   ó@   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zy
)r"   zB
    Refer to FigureFactory.create_streamline() for docstring
    c                 ó~  — t         j                  |«      | _        t         j                  |«      | _        t         j                  |«      | _        t         j                  |«      | _        || _        || _        t        d|z  «      | _	        | j                  d   | j                  d   z
  | _
        | j                  d   | j                  d   z
  | _        | j                  | _        | j                  | _        t         j                  | j                  | j                  f«      | _        t!        | j                  «      t#        | j                  dz
  «      z  | _        t!        | j                  «      t#        | j                  dz
  «      z  | _        g | _        | j                  | j                  d   | j                  d   z
  z  | _        | j
                  | j                  d   | j                  d   z
  z  | _        t         j+                  | j                  dz  | j
                  dz  z   «      | _        | xj                  t!        | j                  «      z  c_        | xj
                  t!        | j                  «      z  c_        g | _        g | _        | j3                  «        | j5                  «       \  }	}
| j7                  «       \  }}y )Né   r	   r   éÿÿÿÿé   )r
   Úarrayr   r   r(   r)   r*   r   Úintr   Údelta_xÚdelta_yÚval_xÚval_yÚzerosÚblankr   ÚfloatÚ	spacing_xÚ	spacing_yÚtrajectoriesÚsqrtÚspeedÚst_xÚst_yÚget_streamlinesr#   r$   )Úselfr   r   r(   r)   r   r*   r   r+   r,   r-   Úarrows_xÚarrows_ys                r   Ú__init__z_Streamline.__init__‰   sõ  € Ü—‘˜!“ˆŒÜ—‘˜!“ˆŒÜ—‘˜!“ˆŒÜ—‘˜!“ˆŒØˆŒ
Ø&ˆÔÜ˜2 ™<Ó(ˆŒØ—v‘v˜a‘y 4§6¡6¨!¡9Ñ,ˆŒØ—v‘v˜a‘y 4§6¡6¨!¡9Ñ,ˆŒØ—V‘VˆŒ
Ø—V‘VˆŒ
ô —X‘X˜tŸ|™|¨T¯\©\Ð:Ó;ˆŒ
Ü˜TŸV™V›¤u¨T¯\©\¸AÑ-=Ó'>Ñ>ˆŒÜ˜TŸV™V›¤u¨T¯\©\¸AÑ-=Ó'>Ñ>ˆŒØˆÔð —‘˜4Ÿ6™6 "™:¨¯©¨q©	Ñ1Ñ2ˆŒØ—‘˜4Ÿ6™6 "™:¨¯©¨q©	Ñ1Ñ2ˆŒÜ—W‘W˜TŸV™V Q™Y¨¯©°©Ñ2Ó3ˆŒ
ð 	�Š”#�d—f‘f“+Ñ�Ø�Š”#�d—f‘f“+Ñ�ØˆŒ	ØˆŒ	Ø×ÑÔØ%)×%9Ñ%9Ó%;Ñ"ˆ�lØ!×7Ñ7Ó9Ñˆ‘(r   c                 ón   — t        || j                  z  dz   «      t        || j                  z  dz   «      fS )zQ
        Set up positions for trajectories to be used with rk4 function.
        ç      à?)r8   r@   rA   )rH   ÚxiÚyis      r   Ú	blank_posz_Streamline.blank_posª   s5   € ô �R˜$Ÿ.™.Ñ(¨CÑ/Ó0´#°r¸D¿N¹NÑ7JÈcÑ6QÓ2RÐSÐSr   c                 ó`  — t        |t        j                  «      r5|j                  t        «      | _        |j                  t        «      | _        n t	        |«      | _        t	        |«      | _        || j                  | j                  f   }|| j                  | j                  dz   f   }|| j                  dz   | j                  f   }|| j                  dz   | j                  dz   f   }|| j                  z
  }|| j                  z
  }	|d|z
  z  ||z  z   }
|d|z
  z  ||z  z   }|
d|	z
  z  ||	z  z   S )zK
        Set up for RK4 function, based on Bokeh's streamline code
        r	   )	Ú
isinstancer
   ÚndarrayÚastyper8   r   r   r;   r<   )rH   ÚarN   rO   Úa00Úa01Úa10Úa11ÚxtÚytÚa0Úa1s               r   Úvalue_atz_Streamline.value_at°   s  € ô �bœ"Ÿ*™*Ô%Ø—Y‘Yœs“^ˆDŒFØ—Y‘Yœs“^ˆD�Fä˜R›ˆDŒJÜ˜R›ˆDŒJØ�—
‘
˜DŸJ™JÐ&Ñ'ˆØ�—
‘
˜DŸJ™J¨™NÐ*Ñ+ˆØ�—
‘
˜Q‘ §
¡
Ð*Ñ+ˆØ�—
‘
˜Q‘ §
¡
¨Q¡Ð.Ñ/ˆØ�$—*‘*‰_ˆØ�$—*‘*‰_ˆØ�A˜‘F‰^˜c B™hÑ&ˆØ�A˜‘F‰^˜c B™hÑ&ˆØ�Q˜‘V‰}˜r B™wÑ&Ð&r   c                 ó‚  ‡ ‡‡‡— ˆ fd„}ˆ fd„}ˆ fd„Šg Šg Šˆˆ ˆˆfd„} ||||«      \  }}} ||||«      \  }	}
}||	z   }|
ddd…   |dd z   }|ddd…   |dd z   }t        |«      dk  ry|dkD  r*‰ j                  ||«      \  }}d‰ j                  ||f<   ||fS t        ‰‰«      D ]  \  }}d	‰ j                  ||f<   Œ y)
zç
        RK4 forward and back trajectories from the initial conditions.

        Adapted from Bokeh's streamline -uses Runge-Kutta method to fill
        x and y trajectories then checks length of traj (s in units of axes)
        c                 óÌ   •— d‰j                  ‰j                  | |«      z  }‰j                  ‰j                  | |«      }‰j                  ‰j                  | |«      }||z  ||z  fS ©Ng      ð?©r^   rD   r(   r)   ©rN   rO   Údt_dsÚuiÚvirH   s        €r   Úfz$_Streamline.rk4_integrate.<locals>.fÌ   s]   ø€ Ø˜$Ÿ-™-¨¯
©
°B¸Ó;Ñ;ˆEØ—‘˜tŸv™v r¨2Ó.ˆBØ—‘˜tŸv™v r¨2Ó.ˆBØ˜‘:˜r E™zÐ)Ð)r   c                 óÐ   •— d‰j                  ‰j                  | |«      z  }‰j                  ‰j                  | |«      }‰j                  ‰j                  | |«      }| |z  | |z  fS ra   rb   rc   s        €r   Úgz$_Streamline.rk4_integrate.<locals>.gÒ   sa   ø€ Ø˜$Ÿ-™-¨¯
©
°B¸Ó;Ñ;ˆEØ—‘˜tŸv™v r¨2Ó.ˆBØ—‘˜tŸv™v r¨2Ó.ˆBØ�3˜‘;   e¡Ð+Ð+r   c                 ó    •— d| cxk  xr t        ‰j                  «      dz
  k  nc xr& d|cxk  xr t        ‰j                  «      dz
  k  S c S )Nr   r	   )r   r   r   )rN   rO   rH   s     €r   ú<lambda>z+_Streamline.rk4_integrate.<locals>.<lambda>Ø   s>   ø€   RÖ 9¬#¨d¯f©f«+¸©/Ô 9Ò W¸aÀ2Ö>WÌÈDÏFÉFËÐVWÉÑ>W€ Ñ>W€ r   c                 ó  •— d}d}| }|}‰j                  ||«      \  }}g }	g }
 ‰||«      �rC|	j                  |«       |
j                  |«       	  |||«      \  }} ||d|z  |z  z   |d|z  |z  z   «      \  }} ||d|z  |z  z   |d|z  |z  z   «      \  }} ||||z  z   |||z  z   «      \  }}|||d|z  z   d|z  z   |z   z  dz  z  }|||d|z  z   d|z  z   |z   z  dz  z  } ‰||«      sn‚||z  }‰j                  ||«      \  }}||k7  s||k7  rM‰j                  ||f   dk(  r8d‰j                  ||f<   ‰j                  |«       ‰j                  |«       |}|}nn|dkD  rn ‰||«      r�ŒC||	|
fS # t        $ r Y Œw xY w)Ng{®Gáz„?r   rM   r6   g      @r	   )rP   ÚappendÚ
IndexErrorr>   )Úx0Úy0rg   ÚdsÚstotalrN   rO   ÚxbÚybÚxf_trajÚyf_trajÚk1xÚk1yÚk2xÚk2yÚk3xÚk3yÚk4xÚk4yÚnew_xbÚnew_ybÚcheckrH   Ú
xb_changesÚ
yb_changess                        €€€€r   Úrk4z&_Streamline.rk4_integrate.<locals>.rk4Ü   sò  ø€ ØˆBØˆFØˆBØˆBØ—^‘^ B¨Ó+‰FˆB�ØˆGØˆGÙ˜˜B•-Ø—‘˜rÔ"Ø—‘˜rÔ"ðÙ   R›y‘H�C˜Ù   c¨B¡h°¡nÑ!4°b¸3À¹8Àc¹>Ñ6IÓJ‘H�C˜Ù   c¨B¡h°¡nÑ!4°b¸3À¹8Àc¹>Ñ6IÓJ‘H�C˜Ù   b¨3¡h¡°°R¸#±X±Ó>‘H�C˜ð �b˜C ! c¡'™M¨A°©GÑ3°cÑ9Ñ:¸SÑ@Ñ@�Ø�b˜C ! c¡'™M¨A°©GÑ3°cÑ9Ñ:¸SÑ@Ñ@�Ù˜R ”}ØØ˜"‘�Ø!%§¡°°BÓ!7‘�˜Ø˜R’< 6¨R¢<Ø—z‘z &¨& .Ñ1°QÒ6Ø56˜Ÿ
™
 6¨6 >Ñ2Ø"×)Ñ)¨&Ô1Ø"×)Ñ)¨&Ô1Ø#˜Ø#™àØ˜A’:Øñ5 ˜˜B–-ð6 ˜7 GÐ+Ð+øô' "ò Ùðús   ÁA E5 Å5	FÆ FNr5   r	   gš™™™™™É?r   )r   rP   r>   Úzip)rH   ro   rp   rg   ri   r„   Úsfru   rv   ÚsbÚxb_trajÚyb_trajrr   Úx_trajÚy_trajÚinitxbÚinitybrs   rt   r�   r‚   rƒ   s   `                  @@@r   Úrk4_integratez_Streamline.rk4_integrateÄ   sü   û€ ô	*ô	,ó YˆØˆ
Øˆ
÷#	,ñJ  # 2 r¨1›~ÑˆˆG�WÙ" 2 r¨1›~ÑˆˆG�WØ�b‘ˆØ™˜2˜‘ ¨¨ Ñ,ˆØ™˜2˜‘ ¨¨ Ñ,ˆäˆv‹;˜Š?ØØ�CŠ<Ø!Ÿ^™^¨B°Ó3‰NˆF�FØ)*ˆD�J‰J�v˜v�~Ñ&Ø˜6�>Ð!ä˜j¨*Ó5ò '‘��BØ%&�—
‘
˜2˜r˜6Ò"ð'àr   c                 ó  — |dk  s#|| j                   k\  s|dk  s|| j                   k\  ry| j                  ||f   dk(  rK| j                  || j                  z  || j                  z  «      }|�| j
                  j                  |«       yyy)z÷
        Integrate trajectories

        :param (int) xb: results of passing xi through self.blank_pos
        :param (int) xy: results of passing yi through self.blank_pos

        Calculate each trajectory based on rk4 integrate method.
        r   N)r   r>   rŽ   r@   rA   rB   rm   )rH   rs   rt   Úts       r   Útrajz_Streamline.traj  s†   € ð �Š6�R˜4Ÿ<™<Ò'¨2°ª6°R¸4¿<¹<Ò5GØØ�:‰:�b˜"�fÑ Ò"Ø×"Ñ" 2¨¯©Ñ#6¸¸T¿^¹^Ñ8KÓLˆAØˆ}Ø×!Ñ!×(Ñ(¨Õ+ð ð #r   c                 ó¦  — t        | j                  dz  «      D ]–  }t        | j                  d|z  z
  «      D ]v  }| j                  ||z   |«       | j                  ||z   | j                  dz
  |z
  «       | j                  |||z   «       | j                  | j                  dz
  |z
  ||z   «       Œx Œ˜ | j                  D �cg c]7  }t        j                  |d   «      | j                  z  | j                  d   z   ‘Œ9 c}| _        | j                  D �cg c]7  }t        j                  |d   «      | j                  z  | j                  d   z   ‘Œ9 c}| _        t        t        | j                  «      «      D ]X  }| j                  |   j                  «       | j                  |<   | j                  |   j                  t        j                  «       ŒZ t        t        | j                  «      «      D ]X  }| j                  |   j                  «       | j                  |<   | j                  |   j                  t        j                  «       ŒZ yc c}w c c}w )z=
        Get streamlines by building trajectory set.
        r6   r	   r   N)r   r   r‘   rB   r
   r7   r9   r   rE   r:   r   rF   r   Útolistrm   Únan)rH   ÚindentrN   r�   r   s        r   rG   z_Streamline.get_streamlines#  sì  € ô ˜DŸL™L¨AÑ-Ó.ò 	BˆFÜ˜DŸL™L¨1¨v©:Ñ5Ó6ò B�Ø—	‘	˜"˜v™+ vÔ.Ø—	‘	˜"˜v™+ t§|¡|°aÑ'7¸&Ñ'@ÔAØ—	‘	˜& " v¡+Ô.Ø—	‘	˜$Ÿ,™,¨Ñ*¨VÑ3°R¸&±[ÕAñ	Bð	Bð @D×?PÑ?Pö
Ø:;ŒB�H‰H�Q�q‘T‹N˜TŸ\™\Ñ)¨D¯F©F°1©IÓ5ò
ˆŒ	ð @D×?PÑ?Pö
Ø:;ŒB�H‰H�Q�q‘T‹N˜TŸ\™\Ñ)¨D¯F©F°1©IÓ5ò
ˆŒ	ô œ3˜tŸy™y›>Ó*ò 	,ˆEØ#Ÿy™y¨Ñ/×6Ñ6Ó8ˆD�I‰I�eÑØ�I‰I�eÑ×#Ñ#¤B§F¡FÕ+ð	,ô œ3˜tŸy™y›>Ó*ò 	,ˆEØ#Ÿy™y¨Ñ/×6Ñ6Ó8ˆD�I‰I�eÑØ�I‰I�eÑ×#Ñ#¤B§F¡FÕ+ñ	,ùò
ùò
s   Ã <I	Ä<Ic                 óÂ  — t         j                  t        | j                  «      «      }t         j                  t        | j                  «      «      }t         j                  t        | j                  «      «      }t         j                  t        | j                  «      «      }t        t        | j                  «      «      D ]ä  }| j                  |   t        t        | j                  |   «      dz  «         ||<   | j                  |   t        t        | j                  |   «      dz  «      dz
     ||<   | j                  |   t        t        | j                  |   «      dz  «         ||<   | j                  |   t        t        | j                  |   «      dz  «      dz
     ||<   Œæ ||z
  }||z
  }t         j                  «       }t         j                  dd¬«       t         j                  ||z  «      }	t        j                  di |¤Ž |	| j                  z   }
|	| j                  z
  }t         j                  |
«      | j                  z  }t         j                  |
«      | j                  z  }t         j                  |«      | j                  z  }t         j                  |«      | j                  z  }t         j                  t        |«      «      }t         j                  t        |«      «      }t         j                  t        |«      «      }t         j                  t        |«      «      }t        t        |«      «      D ]{  }||   dk\  r9||   ||   z
  ||<   ||   ||   z
  ||<   ||   ||   z
  ||<   ||   ||   z
  ||<   ŒD||   ||   z   ||<   ||   ||   z   ||<   ||   ||   z   ||<   ||   ||   z   ||<   Œ} t         j                  t        |«      «      }t         j                  |dd t         j                  ||||g«      }|j!                  d«      }|j#                  «       }t         j                  ||||g«      }|j!                  d«      }|j#                  «       }||fS )	a_  
        Makes an arrow for each streamline.

        Gets angle of streamline at 1/3 mark and creates arrow coordinates
        based off of user defined angle and arrow_scale.

        :param (array) st_x: x-values for all streamlines
        :param (array) st_y: y-values for all streamlines
        :param (angle in radians) angle: angle of arrowhead. Default = pi/9
        :param (float in [0,1]) arrow_scale: value to scale length of arrowhead
            Default = .09
        :rtype (list, list) arrows_x: x-values to create arrowhead and
            arrows_y: y-values to create arrowhead
        é   r	   Úignore)ÚdivideÚinvalidr   NÚFr   )r
   Úemptyr   rE   rF   r   r8   ÚgeterrÚseterrÚarctanr*   Úcosr   Úsinr”   r7   Úflattenr“   )rH   Úarrow_end_xÚarrow_end_yÚarrow_start_xÚarrow_start_yr   Údif_xÚdif_yÚorig_errÚstreamline_angÚang1Úang2Úseg1_xÚseg1_yÚseg2_xÚseg2_yÚpoint1_xÚpoint1_yÚpoint2_xÚpoint2_yÚspacerI   rJ   s                          r   r$   z!_Streamline.get_streamline_arrows=  sÔ  € ô —h‘h¤ D§I¡I£Ó0ˆÜ—h‘h¤ D§I¡I£Ó0ˆÜŸ™¤# d§i¡i£.Ó2ˆÜŸ™¤# d§i¡i£.Ó2ˆÜœ3˜tŸy™y›>Ó*ò 	ˆEØ!%§¡¨5Ñ!1´#´c¸$¿)¹)ÀEÑ:JÓ6KÈaÑ6OÓ2PÑ!QˆK˜ÑØ#'§9¡9¨UÑ#3Ü”S˜Ÿ™ 5Ñ)Ó*¨QÑ.Ó/°1Ñ4ñ$ˆM˜%Ñ ð "&§¡¨5Ñ!1´#´c¸$¿)¹)ÀEÑ:JÓ6KÈaÑ6OÓ2PÑ!QˆK˜ÑØ#'§9¡9¨UÑ#3Ü”S˜Ÿ™ 5Ñ)Ó*¨QÑ.Ó/°1Ñ4ñ$ˆM˜%Ò ð	ð ˜mÑ+ˆØ˜mÑ+ˆä—9‘9“;ˆÜ
�	‰	˜¨8ˆ	Ô4ÜŸ™ 5¨5¡=Ó1ˆÜ
�	‰	Ñ�HÒà §¡Ñ,ˆØ §¡Ñ,ˆä—‘˜“ × 0Ñ 0Ñ0ˆÜ—‘˜“ × 0Ñ 0Ñ0ˆÜ—‘˜“ × 0Ñ 0Ñ0ˆÜ—‘˜“ × 0Ñ 0Ñ0ˆä—8‘8œS ›ZÓ)ˆÜ—8‘8œS ›ZÓ)ˆÜ—8‘8œS ›ZÓ)ˆÜ—8‘8œS ›ZÓ)ˆäœ3˜u›:Ó&ò 
	EˆEØ�U‰|˜qÒ Ø"-¨eÑ"4°v¸e±}Ñ"D�˜‘Ø"-¨eÑ"4°v¸e±}Ñ"D�˜‘Ø"-¨eÑ"4°v¸e±}Ñ"D�˜‘Ø"-¨eÑ"4°v¸e±}Ñ"D�˜’à"-¨eÑ"4°v¸e±}Ñ"D�˜‘Ø"-¨eÑ"4°v¸e±}Ñ"D�˜‘Ø"-¨eÑ"4°v¸e±}Ñ"D�˜‘Ø"-¨eÑ"4°v¸e±}Ñ"D�˜’ð
	Eô —‘œ#˜h›-Ó)ˆÜ—6‘6ˆ‰aˆô —8‘8˜X {°H¸eÐDÓEˆØ×#Ñ# CÓ(ˆØ—?‘?Ó$ˆô —8‘8˜X {°H¸eÐDÓEˆØ×#Ñ# CÓ(ˆØ—?‘?Ó$ˆà˜Ð!Ð!r   c                 ób   — t        | j                  g «      }t        | j                  g «      }||fS )a  
        Makes all streamlines readable as a single trace.

        :rtype (list, list): streamline_x: all x values for each streamline
            combined into single list and streamline_y: all y values for each
            streamline combined into single list
        )ÚsumrE   rF   )rH   r,   r-   s      r   r#   z_Streamline.sum_streamlinesŠ  s/   € ô ˜4Ÿ9™9 bÓ)ˆÜ˜4Ÿ9™9 bÓ)ˆØ˜\Ð)Ð)r   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rK   rP   r^   rŽ   r‘   rG   r$   r#   r   r   r   r"   r"   „   s5   „ ñò:òBTò'ò(Lò\,ò",ò4K"óZ
*r   r"   )ÚmathÚplotlyr   r   Úplotly.figure_factoryr   Úplotly.graph_objsr   Ú
get_moduler
   r   Úpir1   Úobjectr"   r   r   r   ú<module>rÃ      sO   ðÛ ç /Ý 'Ý (à Ð× Ñ  Ó)€òð8  §¡¨1¡¸$ó\7ô~P*�&õ P*r   